Medical diagnostic tool with neural model trained through machine learning for predicting coronary disease from ECG signals

ABSTRACT

A diagnostic tool includes a sensor for capturing at least one biosignal produced by a patient&#39;s heart and a computer device that implements a neural network iteratively trained via machine learning to generate a prediction about a heart condition of the patient. After the neural network is trained, the computer device can convert the at least one biosignal to a multi-dimensional input matrix for the deep neural network generated from a number (N) of biosignals captured by the sensor. The computer device then processes the multi-dimensional input matrix through the deep neural network, which subsequently outputs the prediction about the heart condition of the patient.

PRIORITY CLAIM

The present application claims priority to U.S. Provisional PatentApplication No. 63/055,603, titled MEDICAL DIAGNOSTIC TOOL WITH NEURALMODEL TRAINED THROUGH MACHINE LEARNING FOR PREDICTING CORONARY DISEASEFROM ECG SIGNALS, filed Jul. 23, 2020.

BACKGROUND

Approximately seven million Americans undergo emergency cardiac triageeach year and the length of time to reach a final coronary diseasesdiagnosis is 8 to 72 hours. Also, approximately 40% of patients receiveunnecessary coronary catherization, and 55-85% patients are consideredto be over treated. Despite these measures, 2-6% of sick patients aredischarged without treatment. Nearly 4 million cardiac catheterizationsare performed annually in United States hospitals alone, with one in tendischarges having undergone coronary arteriography. Of these procedures,it is found that over 60% of them find patients with non-obstructivecoronary artery disease—which is surprising as this is an invasive testreserved for the highest risk patients. Tests to indicate coronarydisease, and thus need for cardiac catheterization, are generallyaccurate to an average of about 85%; meaning patients are sent forinvasive catheterization with significant uncertainty of the need forsuch procedure. The innovation presented herein increases this accuracyand therefore provides for better estimate of procedure need, and itdoes so within seconds, and for a fraction of the cost of the hours-longtesting currently used.

SUMMARY

The present invention is directed, in various aspects, to a medicaldiagnostic tool that help doctors (or other applicable health officialsas the case may be) rapidly identify clinically significantcardiovascular disease and sort patients that need further testing fromthose that can be safely discharged. The software-based diagnostic toolcan be trained through machine learning to enable users to betteranalyze and diagnose a patient's ECG signal. The software for the toolcan be used with already cleared/approved ECG devices. The tool'ssoftware is able to accept input from any ECG device, regardless ofdevice gain and sample frequency. The tool employs non-invasivetechnology that uses, for example, standard 12-lead ECG data to predictthe presence, location, and severity of atherosclerotic cardiovasculardisease (ACVD) and coronary artery disease (CAD). The results can beprovided within second, as opposed to hours for current cardiac triagetechniques. Plus, preliminary testing shows that the results are 95%accurate and the accuracy rate will improve with more data because thetool is trained through machine learning.

In one general aspect, the present invention is directed to a diagnostictool that includes: a sensor for capturing at least one biosignalproduced by a patient's heart; and a computer device that implements adeep neural network that is trained iteratively through machine learningto generate a prediction about a heart condition of the patient. Afterthe deep neural network is trained, the computer device is configuredto: convert the at least one biosignal to a multi-dimensional inputmatrix for the deep neural network generated from a number (N) ofbiosignals captured by the sensor, where each of the N biosignals is atleast “T” seconds, and where T is at least one second and N is greaterthan 1; and process the multi-dimensional input matrix through the deepneural network. The output of the deep neural network from processingthe multi-dimensional input matrix corresponds to the prediction aboutthe heart condition of the patient.

In another general aspect, the present invention is directed to a methodincluding: training, with a computer system, iteratively through machinelearning, a deep neural network to make a prediction about a heartcondition of a patient; and after training the deep neural network:capturing, with a sensor, at least one biosignal produced by a patient'sheart; converting, by the computer system, the at least one biosignal toan input matrix for the deep neural network, wherein the input matrixincludes a multi-dimensional matrix generated from a number (N) ofbiosignals of at least “T” seconds (where T is at least one second and Nis greater than 1); and processing, by the computer system, themulti-dimensional input matrix through the deep neural network. Theoutput of the deep neural network from processing the multi-dimensionalinput matrix through the deep neural network corresponds to theprediction about the heart condition of the patient.

In another general aspect, the present invention is directed to acomputer system including one or more processor cores, wherein the oneor more processor cores are configured to: train, iteratively throughmachine learning, a deep neural network to make a prediction about aheart condition of a patient; and after training the deep neuralnetwork: receive, from a sensor, at least one ECG signal produced by apatient's heart and captured by the sensor; convert the at least one ECGsignal to an input matrix for the deep neural network, wherein the inputmatrix includes a multi-dimensional (or multi-axis) matrix generatedfrom N ECG signals of at least T seconds, where T is at least one secondand N is greater than 1; and process the input matrix through the deepneural network, wherein an output of the deep neural network fromprocessing the input matrix through the deep neural network correspondsto the prediction about the heart condition of the patient.

The present invention, in various embodiments, provide many benefitsover prior art systems. First, as described herein, the diagnostic toolcan accurately and rapidly detect coronary diseases of a patient basedon, for example, ECG signals of the patient. Second, the diagnostic toolcan provide those accurate and rapid results even if not all twelve ECGleads are used on the patient. These and other benefits of the presentinvention will be apparent from the description to follow.

FIGURES

Various aspects of the present invention are described herein by way ofexample in connection with the following figures.

FIG. 1 is diagram of a medical diagnostic tool according to variousaspects of the present invention.

FIGS. 2 and 3 depict a process for training and validating a neuralmodel of the medical diagnostic tool of FIG. 1 according to variousaspects of the present invention.

FIG. 4 depicts outputs of the neural model of the medical diagnostictool of FIG. 1 according to various aspects of the present invention.

FIGS. 5A-B and 6A-B depict visualizations generated by the medicaldiagnostic tool of FIG. 1 according to various aspects of the presentinvention.

FIG. 7 is a diagram that depicts the neural model of the medicaldiagnostic tool of FIG. 1 according to various aspects of the presentinvention.

FIG. 8 depicts a densely connected convolutional network that can beused as part of the neural model of the medical diagnostic tool of FIG.1 according to various aspects of the present invention.

FIG. 9 is a block diagram of the computer device of the medicaldiagnostic tool of FIG. 1 according to various aspects of the presentinvention.

DESCRIPTION

The present invention is directed, in various aspects, to a medicaldiagnostic tool 100 for identifying clinically significantcardiovascular disease in a patient 101. In various aspects, thediagnostic tool 100 includes, as shown in FIG. 1 , at least one sensorconfigured to capture biosignals associated with the patient. Forexample, the sensor 102 of FIG. 1 includes one or more leads of an ECGmachine. Although the non-limiting aspect of FIG. 1 includes an ECGmachine with one or more leads, it shall be appreciated that the sensor102 can include any number of devices configured to capture any numberof biosignals associated with the patient. For example, in othernon-limiting aspects, the sensor 102 can include an electroencephalogram(EEG) machine. In still other non-limiting aspects, the sensor 102 caninclude a wearable device (e.g., a smart watch, a smart ring, a smartphone, or smart glasses, etc.) configured to generate either ECG or EEGsignals. HEARTio. Furthermore, the sensor 102 can include any number ofleads. According to the non-limiting aspect of FIG. 1 , the sensor 102could be a conventional 12-lead ECG machine, although other types ofmachines with any number of leads could be used. The sensor 102 can becommunicably coupled to a back-end computer device 104, sometimesreferred to herein as a “HEARTio computer.” The computer device 104includes modules 108 trained through machine learning to identify theexistence (or non-existence) of one or more clinically significantcardiovascular diseases based on the ECG data from a patient.

The HEARTio computer 104 stores and executes a software program 108 thatanalyses a patient's biosignals (e.g., 12-lead ECG data) and outputs apredicted level, severity, and localization of coronary stenosis orother coronary diseases that the software is trained, through machinelearning, to identify. The ECG data can be input, for example, tocomputer device 104 in the following ways: (1) Direct input of digitaldata points in a patient dataset via the hospital infrastructure; (2)Manual input of a digital signal file through an email client; (3)Manual input of a digital signal data via a dashboard provided by thecomputer device 104; and/or (4) Manual input of an biosignal waveform(non-digital signal such as a pdf or image) via a dashboard. For thislast option, the computer device 104 can transform the non-digitalsignal into a set of a digital signal data. The computer device 104could have a direct wired network (e.g., an Ethernet) or wireless (e.g.,WIFI) connection to the computer device 104. Also, the computer device104 could be on the cloud, in which case the biosignal data from apatient is uploaded to a database on the cloud, which database thecomputer device 104 can access to analyze the patient's biosignal datato make the diagnosis.

The software program 108 can include one or more neural models and,after input of biosignal data, the data is pushed through the neuralmodel(s), sometimes referred to herein as a “HEARTio neural model” asshown in FIG. 1 , implemented by the software 108 of the HEARTiocomputer 104. In that connection, the HEARTio neural model 108 can be afixed graph that has a very specific set of instructions for how toprocess the input data. Then HEARTio computer 104 can separate thebiosignal data into more than, for example, 100 distinct layers of thegraph (or neural network) by applying a specific set of mathematicaloperations to the data exiting the preceding layer in the neural graph.The final layer of the HEARTio neural model 108 preferably provides anarray of probabilities for the question being asked (Is this biosignalrepresentative of coronary stenosis? How severe is this coronarystenosis? What is the location of the coronary stenosis? etc.)

The difference between a normal software program and the HEARTio neuralmodel 108 is that the set of instructions for the HEARTio neural model108 is not determined by a physician, programmer, or expert, but by theHEARTio computer 104 itself. A typical software program implements aknown flow of information through a fixed set of code to performprocesses on the data, but those processes are designed by theprogrammer. With the diagnostic tool 100 of the present invention, thedetermination of these instructions is done algorithmically, meaning theHEARTio computer 104 itself determines what mathematical operations areused to operate on data exiting one layer of the graph and beingdelivered to the next layer. A training set of data is used to train theneural model 108 using, for example, supervised, unsupervised, and/orsemi-supervised training. The graph is initially set up to use arandomly generated set of instructions to deliver the next layer of datafrom the preceding layer, with the first layer being the “training set”of biosignal data, singularly, for each patient in the “training set”.

The biosignal data in the training set is pushed through the variouslayers of the graph, with its mathematical operations between eachlayer, and then, after the last layer, the initial set of answers arerecorded. In supervised training, the answers are known, as part of theiterative training, the answers produced by the model 108 can becompared to the actual answers/results associated with the trainingdata. If the experimental results and the expected results are far awayin magnitude, then the instructions representing the mathematicaloperations between the layers is adjusted (done by the HEARTio computer104 according to an algorithm) to move the model 108 closer to a set ofoperations that may offer better results at the end of the last layer.If the distance between the real answer and the answer computed by thecombination of the all the operations between the numerous layers in thegraph is minimal, possibly only the operations between lower levels areadjusted. This process is repeated, over and over, until the congruencebetween the experimental results and the expected results aresatisfactory, at which point the model of mathematical operationsbetween the layers can then be applied on additional patient biosignaldata.

After training has concluded, the final graph (set of mathematicaloperations acting between the various layers of the model) is fixed andready to be used to process biosignal data that was not included in thetraining set. The process of inputting new data to the neural model 108is called “testing”. The main advantages to allowing the computer 104 todetermine the optimal set of instructions are that a) it can revise theinstructions and evaluate the results much more quickly than with humaninvolvement, b) it can use a much more complicated instruction set thancan be envisioned by humans, and c) it can update the instructions withthe acquisition of new data to get, theoretically, more and moreaccurate results with more and more experience. Thus, the biosignalneural model 108 will adapt to novel data, leading to more accurateanalysis of biosignal data with respect to coronary stenosis or othermonitored-for conditions as the case may be.

FIG. 2 depicts the training and validation processes 200 in more detail.The patient cohort is split into two groups: a “training set” 202 and a“testing set” 204. Generally accepted deep learning practice is toutilize greater than 90% of the patient cohort for the training set 202and the remainder to validate the accuracy statistics of the model 206.The programmer may also manually set the hyperparameters, for thetraining, which are parameters unrelated to the training set but willimpact the training environment (e.g., learning rate, label smoothing,dropout rate). Once the patient cohort is split and before trainingbegins, the model randomizes the model 206 parameters it will refine tobuild the statistical dependencies between input and output. Over timethe model 206 improves upon these parameters utilizing a process knownas gradient descent, in which each of the parameters searches for localminimums of a loss function (the measure of how different the predictionis from the actual value).

Training the model 206 is iterative (as shown in FIG. 3 ). The number ofepochs (a measure of how many forward and backward passes the model 206makes as part of the iterative gradient descent training), and thenumber of steps per epoch (a measure of how many data points areevaluated within the epoch) may be set by the programmer. In each epoch,a training set is randomly pulled from the training cohort 204. Themodel 206 then makes predictions about the patient based on patientbiosignals, trying to identify important parameters that make thecorrect diagnosis. Once the forward pass (forward propagation) iscomplete, the predictions are sent to the loss function, which comparesthe predictions against the actual patient conditions and determines theoverall error. This error then gets back-propagated through the model206 and helps adjusts parameters to correct for the model 206 error.

After all the epochs are complete, the final model 206 is considered“trained” and that model is passed to testing. This trained model 206 isthen given the previously defined “testing set”, which it has neverseen, to predict patient conditions. These predictions are compared tothe actual patient outcomes and these results are reported as model 206performance (usually in terms of sensitivity, Positive Predictive Value(PPV), and F-1 score).

The longer the duration of the input 208 fed into the HEARTio neuralmodel 206 generally the better. Preferably, the duration of the input208 should be at least one second. In various aspects, the input 208(FIG. 4 ) that is fed into HEARTio neural model 206 is more than 5seconds and less than 15 seconds, such as ten seconds, of standard ECGsignals (or other biosignals as the case may be) and can be anywherefrom one to twelve leads. The model 206 output 210 (FIG. 4 ) caninclude, for example, in six different but related areas: beatclassification, rhythm classification, Myocardial Infarction (MI)classification, Major Adverse Cardiovascular Events (MACE) prediction,and CAD severity classification. Of course, the output 210 can includeany other information associated with the heart of the patient 101 (FIG.1 ) as determined by the model 206. Unlike most current biosignalinterpretation software, which simply monitors basic beats, rhythm, andMI detection, the HEARTio computer 104 (FIG. 1 ), with its HEARTioneural model 206, can be trained to detect, for example, 17 differentand highly clinically relevant beat types, 17 different and highlyclinically relevant rhythm types, and five different and highlyclinically relevant MI types. The HEARTio computer 104 (FIG. 1 ) canprovide this improvement through in MACE prediction, and CAD severityclassification prediction. The HEARTio neural model 206 can be trainedto predict a patient's risk for a MACE, determine that patient's currentlevel of CAD, and localize stenosis in the patient's coronary arteries.The outputs that the HEARTio neural model 206 can be trained, in variousaspects, to detect are listed in Table 1 below.

TABLE 1 Beats Rhythm Possible Labels Possible Labels Aberrated atrialpremature beat Atrial fibrillation Atrial escape beat Atrial flutterAtrial premature beat First heart block Fusion of paced and normal beatIdioventricular rhythm Fusion of ventricular and normal beat Nodal (A-Vjunctional) rhythm Left bundle branch block beat Noise Nodal(junctional) escape beat Normal sinus rhythm Nodal (junctional)premature beat Paced rhythm Non-conducted P-wave (blocked APC)Pre-excitation (WPW) Normal beat Second heart block Paced beatSupraventricular tachyarrhythmia Premature ventricular contractionVentricular bigeminy Right bundle branch block beat Ventricular flutterSupraventricular premature or Ventricular tachycardia ectopic beat(atrial or nodal) Unclassifiable beat Ventricular trigeminy Ventricularescape beat Atrial bigeminy Ventricular flutter wave Sinus bradycardiaMI MACE Risk Severity Localization Possible Possible Possible VesselBlockage Labels Labels Labels Percentage Acute MI None Low/Mild LAD %Prior MI MI Moderate LCX % NSTEMI Stroke Severe LM % Prior CABG SyncopeRCA % Prior PCI

The HEARTio computer device 104 (FIG. 1 ) may also be programmed togenerate graphical displays that display the results of its analysis,which can be accessed via a display 108 (FIG. 1 ) communicably coupledto the computer device 104 (FIG. 1 ). For example, the graphical outputdisplays could be displayed on a monitor of the HEARTio computer deviceor on another device, e.g., the user device 108 shown in FIG. 1 , thatis in data communication with the HEARTio computer device 104 (FIG. 1 ).For example, the HEARTio computer device 104 (FIG. 1 ) could include aweb server that serves the results via web pages to the user device 108(FIG. 1 ). FIGS. 5A-B and 6A-B show example graphical output displays500, 510 that can be generated by the HEARTio computer device 104 (FIG.1 ). FIG. 5A is an example graphical display 500 that could bedisplayed, for example, to an emergency medicine physician or a triagenurse. The example 500 of FIG. 5A can include a preliminary assessment502 of the patient's heart, an ischemia assessment 504 include anestimated risk of CAD, and a MACE assessment 506, all of which aredetermined by the trained model 206 (FIGS. 2-4 ). The display 500 ofFIG. 5A can be used by an ED physician. It includes fields that convey:whether the patient's beats and rhythms are normal or not and whether MIis present 502; an ischemia assessment 504, such as whether there is CADrisk or whether vessel diseases was detected; and a MACE assessment 506,including the risk of 12 month MI, 12 month stroke, and 12 monthsyncope. The biosignal (e.g., ECG, EEG, etc.) waveforms 508 at thebottom of FIG. 5A show most important biosignal leads that contribute tothe severity distinction as determined by the HEARTio neural map. Asecond graphical display, such as the display 510 of FIG. 5B, caninclude fields that show biosignal morphology 512, important biosignalleads 514, whether abnormal beats were detected 516, whether abnormalrhythms were detected 518, occlusion amounts (e.g., percentages) ofvarious arteries 520, as well as biosignals from various leads (e.g.,the important leads) 522. For example, as shown in FIG. 5B, the outputvisualization can show the percent lesion blockage 520 within each ofthe 4 major coronary arteries. If the blockages are low, moderate, orhigh, they can be shaded differently (e.g., green, yellow, red).

FIGS. 6A and 6B shows other graphical visualizations 600, 610 that canbe provided by the computer system 104 (FIG. 1 ). The visualization 600of FIG. 6A shows the predicted levels of 4 different blood tests 602,604, 606, 608 that the HEARTio model 206 (FIGS. 2-4 ) has generatedoutputs for. Once again, the graphical visualization 600 can use colorcoding to visually communicate information to a using technician. Forexample, if the levels are low the bars can be green; if they aremoderate it will be yellow; and if they are high it will be red (or someother color coding). The visualization 610 of FIG. 6B shows the level ofejection fraction. The higher the level the heart graphic fills up. Ifthe EF is low, the color in the graphic can be yellow and, if evenlower, red (or some other color coding).

In various aspects, the input to HEARTio neural model 206 (FIGS. 2-4 )is a tensor with 4 axes: batch, signal, lead, and channel. The batchaxis refers to the total number of biosignal that are being processed atthe same time; if a single biosignal is being evaluated then the batchaxis size would be 1. The signal axis represents the discrete numericalsignal value for 10 seconds of time; in various aspects, the size ofthis axis is nonvariable and is 1000. The lead axis represents thestandard 12 leads that include a resting biosignal; and this axis can benonvariable in certain aspects. The channel axis is preferablynonvariable as well and set to 1. This axis is used as a convenience forconvolutional processing. Overall a biosignal can be represented by12,000 double (float32) values. Many biosignal algorithms are based onthe concept of rule-based analysis, meaning that are rules set in stonedetermined by expert opinion or rudimentary analysis. This type ofanalysis usually requires the manual input of demographic informationsuch as sex, age, race, family history. The HEARTio neural model doesnot require any further input than the biosignal represented in tensorform and can be blind to any other information.

The tensor form biosignal, for example, can include a conventional ECGwith anywhere from 1 to 12 leads organized as shown in Table 2 below.Alternatively, the tensor form biosignal can include a conventional EEGwith anywhere from 1 to 19 leads. If a lead does not exist in theoriginal signal it is replaced by a series of zeros. If the tensor formbiosignal was extracted from an image or PDF there might a series ofzeros in different parts of various leads.

TABLE 2 ECG leads and their respective index in the lead axis Lead LeadAxis Index I 0 II 1 III 2 aVR 3 aVL 4 aVF 5 V1 6 V2 7 V3 8 V4 9 V5 10 V611 X 0 Y 1 Z 2

To create a biosignal in tensor form the following steps may befollowed. First, clip a biosignal such that it represents (for example)10 seconds and is in the form N×M, where M is the number of the leadsand N is the number of samples. N is equal to the sampling rate of thebiosignal multiplied by 10. Second, using fast Fourier transform (FFT),resample N to 1000, in effect reducing the sampling rate to 100 Hz.Third, bandpass Butterworth filter with a passband starting at 2 Hz andextending to 40 Hz. This will try to make sure only the informationwithin this band of frequencies are retained while others are removed.Fourth, each filtered signal can be scaled by the following formula:

${f(x)} = {{2\frac{x - {\min(x)}}{{\max(x)} - {\min(x)}}} - 1}$This will make every value between −1 and +1. Fifth, any NaN value canbe converted to 0. And sixth, each signal can be detrended such that theisoelectrical portions of the biosignal are 0. After this level ofpreprocessing there still might be signals, or leads of signals, that donot have a reasonable amount or degree of usable information. In thatcase, there is a series of steps that are used in training the neuralmodel that can also be used to disregard the signals without usableinformation.

The outputs of HEARTio neural model can fit into the following majorarchetypes, where each index of the output array represents a class orcategory:

-   -   1. Reconstruction: Array is the form of a reconstructed        biosignal.    -   2. Scaled-Continuous: Values in this output array are continuous        but scaled to be between 0 and 1.    -   3. Multi-Class: Each output array can only contain 1 value of 1,        all other values are 0. There is only 1 class that be present.    -   4. Multi-Label: Each output array can have multiple values of 1.        Each class can be present or absent.        Table 3 below shows an example macro listing of output of the        HEARTio neural model and the shaped associated with each output.

TABLE 3 Output Name Length Type Reconstruction ECG {1000, 12, 1}Reconstruction Coronary Blockage % 4 Scaled-Continuous MI & History 5Multi-Label Abnormal Beats 17 Multi-Label Abnormal Rhythms 17Multi-Label SPECT 20 Scaled-Continuous MACE Risk 4 Multi-Class CADSeverity - Overall 3 Multi-Class CAD Severity - Leads 3 Multi-ClassCoronary Binary Blockage 4 Multi-Label Blood Test Predictions 4Scaled-Continuous Complications 4 Multi-Label Ejection Fraction 1Scaled-Continuous Disease 1 Multi-Label Conduction Disorders 11Multi-Label Hypertrophy 5 Multi-Label Location of MI 14 Multi-LabelMorphology 15 Multi-Label ST-T Changes 13 Multi-Label Ejection FractionBinary 1 Multi-Label FFR 1 Scaled-Continuous FFR Binary 1 Multi-LabelTable 4, in Appendix A hereto, shows the indexes within each majorcategory according to various aspects of the present invention.

In various aspects, the basis of HEARTio neural model 206 (FIG. 2 ) isthe development and training of three distinct models that work inconcert to provide information and thoroughly analyze biosignals. Thesteps of the HEARTio neural model 206 (FIG. 2 ), once trained, are asfollows, with reference to FIG. 7 :

-   -   1. A biosignal 701 is input and processed through an encoder 704        which performs a lossy compression    -   2. The minimized representation of this lossy compression,        called the latent space 708, serves as input to two layers: a        concatenation layer 716 (used later on), and a decoder 706    -   3. The decoder 706 converts the latent space representation 708        back into the tensorform biosignal 710    -   4. The tensorform biosignal 710 is input into a Dense network        712 to produce a feature vector 714    -   5. The feature vector 714 and the latent space 708 are        concatenated to form one feature vector 716, which is used as        input to a classifier 718    -   6. Outputs 720 from the classifier 718 are collected at the end

The encoder 704 and decoder 706 form an autoencoder 702. The autoencoder702 can use information about the biosignal and any extra leads toremove non-significant noise from the biosignal in its reconstruction.The autoencoder 702 can also detect with biosignal leads are empty and,in various aspects, fill them in accordingly using information fromexisting leads. For example, where there is just one existing lead, theautoencoder 702 can generate the 11 other, missing leads so that thereare 12 signals to be used by the dense network 712. The autoencoder 702can also standardize the biosignals such that there is no artifact thatis only related to one type of biosignal lead or patient.

In various aspects, the encoder 704 can include approximately 13.5million total parameters, with approximately 99.97% of them beingtrainable parameters (with the remainder being non-trainableparameters), as shown in Table 5 at Appendix B. Table 6 at Appendix Cshows, in one aspect, a detailed description of each type, output shape,and number of parameters associated with each later of the decoder ofFIG. 7 . Table 7 below shows, in one aspect, a detailed description ofeach type, output shape, and number of parameters associated with eachlayer of the overall autoencoder 702. The encoder 704 can be configuredto perform a lossy compression of the at least one biosignal captured bythe sensor 102 (FIG. 1 ), thereby producing a latent spacerepresentation 708 as an output of the lossy compression. The decoder706 receives the latent space representation 708 as an input from theencoder 704 and can be configured to convert the latent spacerepresentation 708 into a tensorform signal output 710 provided to theDenseNet neural network 712.

TABLE 7 Model: “Autoencoder” Layer (type) Output Shape Param # input 3(InputLayer) (None, 1000, 12, 1) 0 Encoder (Model) (None, 1024) 13451936Decoder (Model) (None, 1000, 12, 1) 13324801 lead adjuster 1(LeadAdjusted) (None, 1000, 12, 1) 1 Total params: 26,776,738 Trainableparams: 26,746,018 Non-trainable params: 30,720

The DenseNet 712 shown in FIG. 7 may be implemented with a form of adeep neural network 712, including an input layer 802, an output layer808, and one or more hidden layers 804, 806 between the input layer 802and output layers 808 (see FIG. 8 ), where each layer includes at leastnode, and directed arcs between nodes. An output value for each node canbe computed by the computer system according to an activation functionfor the node, where the inputs to the activation function for a node areweighted outputs of the node(s) having directed arcs to the node forwhich the activation value is being computed. The weights for the arcsand any applicable bias values can be learned parameters that arelearned through the training. In various aspects, the dense network 712shown in FIG. 7 can be implemented with a densely connected neuralnetwork (DenseNet) 712. In such a DenseNet 712, each layer obtainsadditional inputs from all preceding layers and passes own its ownfeature-maps to all subsequent layers. Concatenation 716 during forwardpropagation can be used, such as shown in FIG. 8 , wherein the circlec's denote concatenation. Each layer 802, 804, 806, 808 can receive a“collective knowledge” from all preceding layers of the neural network712. For example, after receiving the tensorform signal output 710 fromthe decoder 706 of the autoencoder 702, the DenseNet 712 can beconfigured generate a feature vector 714 based, at least in part, on thetensorform signal 710. The DenseNet 712 of FIG. 8 can include an inputlayer 802, a concatenation layer 804, a classifier layer 806, and anoutput layer 808. According to the non-limiting aspect of FIG. 8 , theconcatenation layer 804 can be configured to receive the feature vectorfrom the input layer 802 and the latent space representation into aconcatenated feature vector However, it shall be appreciated that inother non-limiting aspects, the DenseNet 712 can include these and anyother layers configured to generate outputs that can produce meaningfulpredictions regarding the heart condition of the patient. In that case,the network 712 can be relatively thinner and compact, resulting in highcomputational efficiency and memory efficiency. Table 8 in Appendix Dprovides a detailed description of each type, output shape, number ofparameters, and connections associated with each layer of the densenetwork according to one aspect of the present invention.

Table 9 in Appendix E provides a detailed description of the full neuralnetwork, including the encoder, decoder and dense network, according tovarious aspects of the present invention.

As mentioned above, the HEARTio neural model can be trained to work withall twelve leads of a standard 12-lead ECG machine or with less than allof the leads downs to just one lead. During training, the followingadjust adjustment process can be used to adjust the training data totrain the HEARTio neural model to work with 1 to 12 leads.

-   -   If the training data has 12 leads:        -   X1% chance of leaving the signal as is        -   X2% chance of randomly choosing 1 lead        -   X3% chance of randomly choosing up to 11 leads        -   X4% chance of removing 75% of each lead    -   where X1+X2+X3+X4=100%    -   If input ECG training data has greater than 1 but less than 12        leads        -   Y1% chance of leaving the signal as is        -   Y2% chance of randomly choosing 1 lead        -   Y3% chance of randomly choosing up to N−1 leads    -   where Y1+Y2+Y3=100%; and    -   If input ECG has only 1 lead, leave signal as is.

The autoencoder 702 (FIG. 7 ) may employ a reconstruction loss functionto make that the autoencoder's 702 (FIG. 7 ) reconstruction remains asfaithful to the input biosignal. The reconstruction loss function may bebased on a squared difference between the fast Fourier transform (FFT)between the input lead 701 (FIG. 7 ) (if available) and the output lead710 (FIG. 7 ) from the autoencoder 702 (FIG. 7 ). Values with 0s in thebiosignal can be ignored and not considered. The loss can be average perinput signal.

The loss function set forth below can be used by any output that is ofthe scaled-continuous variety. Input biosignals that contain −1 can bemasked and ignored. Each of the gold-truth outputs can be stratifiedinto, for example, 25 bins that are evenly distributed between 0 and 1.Each bin can be cycled through and the mean squared log error (MSLE)between the predicted and true arrays that correspond to a particularbin can be calculated. This can be performed for every index found inthe scaled-continuous output. The loss can be averaged among all indexesand bins.

def weighed_stats_MSLE ( y_true ,y_pred ) :  mask_true = K. c a s t (K.not_equal ( y_true , −1) , K. f l o a t x ( ) )  num_true = K.sum(mask_true )  nbins = 25  indic e s = t f . histogram_fixed_width_bins (mask_true * y_true , ¥   [0 .0 , 1.0] , nbins = nbins )  num_class =y_true . get shape ( ) . a s li s t ( ) [ − 1]  unique , = tf.unique (K.f l a t t e n ( i n d i c e s ) )  unique = K.sum(K. c a s t (K. o n e sli ke ( unique ) , K. f l o a t x ( ) ) )  first_log = K. l o g (K. c li p ( mask_true * y_pred , K. e p s i l o n ( ) , None ) + 1 . ) second_log = K. l o g (K. c l i p ( mask_true * y_true , K. e p s i l on ( ) , None ) + 1 . )  mse = K. square (first_log − second_log)  loss =0 . 0  for j in range ( nbins ) :   inds = mask_true *K. c a s t (K.equal ( i n d i c e s ,   j ) , K. f l o a t x ( ) )   for i in range (num_class ) :    loss += 1 . 0 / ( unique * num_class ) *K.sum(¥    inds[ : , i ] * mse [ : , i ] ) / (K.sum( inds [ : , i ] ) + K. e p s i l on ( ) )  return loss

Also, the loss function set forth below can be used by the any outputthat is of the multi-class variety. Input biosignals contain an indexthat is considered a dummy index. For example, CAD Severity—Overall, has3 indexes that are correlated to the three possible mutually exclusivecategories. The output can be given 4 indexes overall if a data pointdoes not have a label for this output. During training if a biosignaldoes not have a label for the output, the dummy index is occupied, butwith this loss function, the dummy index is ignored. The categoricalcross-entropy is calculated and averaged along legitimate outputs.According to some non-limiting aspects, if the output does not have acorresponding label, the computer system 104 (FIG. 1 ) can create alabel on the fly that corresponds to the output that did not previouslyhave a corresponding label.

def f (y_true, y_pred ):  sum_cols = K. c l i p (K.sum(y true , a x i s= 0 ) , 0 . 0, 1 . 0 )  num_in = K.sum( sum cols [ 0 : mask_value ] ) +K. e p s i l o n ( )  c_ce = K. c a t e g o r i c a l cross entropy (y_true , y_pred )  loss = 0 . 0  for i in range ( mask value ) :   intermask = K. c a s t (K. equal (K. argmax (y_true) , i ) , K. f l o a t x () )   loss += 1 . 0 / ( num in ) *K.sum( inter_mask * c_ce ) ¥  /(K.sum( inter_mask ) + K. e p s i l o n ( ) ) return loss

The loss function below can be used by the any output that is of themulti-label variety. Input biosignals that contain −1 can be masked andignored. Binary cross-entropy can be calculated for both the trueoutputs and the predicted outputs. The cross-entropy values can beaverage for each of the indexes in the output and then the cross-entropyvalues for the 1 and 0 values. Only the indexes that exist in the trueoutput are considered in the loss.

def binary_loss ( y_true , y_pred ):   mask_true = K. c a s t (K. n o teq u al ( y_true , mask_value ) , K. f l o a t x ( ) )  y_pred =mask_true * y_pred  y_true = mask_true * y_true  loc_0 = mask_true *K. ca s t (K. equal ( y_true , 0 ), K. f l o a t x ( ) )  loc_0_ve_c =K.sum( loc_0 , a x i s = 0 )  loc_1_ve_c = K.sum(y_true , a x i s = 0 ) b _ce = K. b i n a r y _crossentropy ( y_true , y_pred )  loss_0 =K.sum( loc_0 * b_ce , a x i s = 0 )/( loc_0_ve_c + K. e p s i l o n ( ))  loss_1 = K.sum( y_true * b_ce , a x i s = 0 )/( loc_1_ve_c + K. e p si l o n ( ) )  loss_0 = K. mean( tf .boolean_mask ( loss_0 , t f . g r ea t e r ( loc_0_ve_c , 0 ) ) )  loss_1 = K. mean( t f .boolean_mask (loss_1 , t f . g r e a t e r ( loc_1_ve_c , 0 ) ) )  loss_0 = t f. cond( t f. math . is_nan ( loss_0 ), lambda :0. 0 , lambda : loss_0 ) loss_1 = t f. cond ( t f. math . is_nan ( loss_l ), lambda :0. 0 ,lambda : loss_1 )  bottom = K. c l i p (K.sum( loc_0_ve_c ) , 0 . 0 ,1 .0) + ¥  K. c l i p (K.sum( loc_1_ve_c ), 0.0 , 1 .0 ) + K. e p s i l o n( )  loss = (loss_1 + loss_0 )/ bottom  return loss

The loss function below is used by HEARTio for explicit semi-supervisedlearning. The concatenated feature vector is used to create a referencesimilarity matrix. Each output of HEARTio is then used to create acomparative similarity matrix. Signals that are similar across thefeature vector space should be similar across the output space as well.Binary cross entropy is done between the reference similarity matrix andeach output comparative matrix and then averaged.

def get_mat ( feature):  r = tf.reduce_sum(feature*feature, 1)  r = tf.reshape(r, [− 1, 1])  D = −1*(r − 2*tf .matmul(feature, feature ,transpose _b=True) \  + tf.transpose(r))  return (D − K.min(D) + 1 e−7)/(K.max(D) − K.min(D) + 1 e−7) def calculate_SSL_loss (reLmat,outpuLlist):  num_outputs = len (output_list)  A = get_mat ( ref_mat) loss = 0.0  for output in output_list:   inter_mat = get_mat(output)  loss += 1.0/ num_outputs*\   K. mean(K. binary_crossentropy (A,inter_mat))  return loss def SSL_wrapper(ref_mat , output_list):  returnK.in_train_phase (calculate_SSL_loss (ref_mat, output_list) ,0.0)

FIG. 9 is a block diagram 2400 of a HEARTio computer device, such as thecomputer device 104 (FIG. 1 ), according to various aspects of thepresent invention. The illustrated computer device 2400 includesmultiple processor units 2402A-B that each includes, in the illustratedaspect, multiple (N) sets of processor cores 2404A-N. Each processorunit 2402A-B may include onboard memory (ROM or RAM) (not shown) andoff-board memory 2406A-B. The onboard memory may include primary,volatile, and/or non-volatile storage (e.g., storage directly accessibleby the processor cores 2404A-N). The off-board memory 2406A-B mayinclude secondary, non-volatile storage (e.g., storage that is notdirectly accessible by the processor cores 2404A-N), such as ROM, HDDs,SSD, flash, etc. The processor cores 2404A-N may be CPU cores, GPU coresand/or Al accelerator cores. GPU cores operate in parallel (e.g., ageneral-purpose GPU (GPGPU) pipeline) and, hence, can typically processdata more efficiently that a collection of CPU cores, but all the coresof a GPU execute the same code at one time. Al accelerators are a classof microprocessor designed to accelerate artificial neural networks.They typically are employed as a coprocessor in a device with a hostprocessor 2410 as well. An Al accelerator typically has tens ofthousands of matrix multiplier units that operate at lower precisionthan a CPU core, such as 8-bit precision in an Al accelerator versus64-bit precision in a CPU core.

In various aspects, the different processor cores 2404 may train and/orimplement different components of the HEARTio neural model. For example,in one aspect, the cores of the first processor unit 2402A may implementthe autoencoder, and the second processor unit 2402B may implement thedense network. In other aspects, one or more of the processor cores 2404and/or one or more of the processor units could implement othercomponents in the HEARTio neural model. One or more host processors 2410may coordinate and control the processor units 2402A-B.

In other aspects, the system 2400 could be implemented with oneprocessor unit 2402. In aspects where there are multiple processorunits, the processor units could be co-located or distributed. Forexample, the processor units 2402 may be interconnected by datanetworks, such as a LAN, WAN, the Internet, etc., using suitable wiredand/or wireless data communication links. Data may be shared between thevarious processing units 2402 using suitable data links, such as databuses (preferably high-speed data buses) or network links (e.g.,Ethernet).

The software for the HEARTio model network and other computer functionsdescribed herein may be implemented in computer software using anysuitable computer programming language, such as .NET, C, C++, or Python,and using conventional, functional, or object-oriented techniques. Forexample, the HEARTio neural mode may be implemented with softwaremodules stored or otherwise maintained in computer readable media, e.g.,RAM, ROM, secondary storage, etc. One or more processing cores (e.g.,CPU or GPU cores) of the machine learning system may then execute thesoftware modules to implement the function of the respective machinelearning system (e.g., student, coach, etc.). Programming languages forcomputer software and other computer-implemented instructions may betranslated into machine language by a compiler or an assembler beforeexecution and/or may be translated directly at run time by aninterpreter. Examples of assembly languages include ARM, MIPS, and x86;examples of high-level languages include Ada, BASIC, C, C++, C#, COBOL,Fortran, Java, Lisp, Pascal, Object Pascal, Haskell, ML; and examples ofscripting languages include Bourne script, JavaScript, Python, Ruby,Lua, PHP, and Perl.

The examples presented herein are intended to illustrate potential andspecific implementations of the present invention. It can be appreciatedthat the examples are intended primarily for purposes of illustration ofthe invention for those skilled in the art. No particular aspect oraspects of the examples are necessarily intended to limit the scope ofthe present invention. Further, it is to be understood that the figuresand descriptions of the present invention have been simplified toillustrate elements that are relevant for a clear understanding of thepresent invention, while eliminating, for purposes of clarity, otherelements. While various aspects have been described herein, it should beapparent that various modifications, alterations, and adaptations tothose aspects may occur to persons skilled in the art with attainment ofat least some of the advantages. The disclosed aspects are thereforeintended to include all such modifications, alterations, and adaptationswithout departing from the scope of the aspects as set forth herein.

As previously discussed, deep learning, and machine learning models areemployed by the HEARTio computer device disclosed herein to classifyinput biosignals such as electrocardiograms (ECGs) andelectroencephalograms (EEGs), for example. Such biosignals can usesignal-based methods such as recurrent neural networks, or long-termshort-term memory models. HEARTio converts the biosignals into amulti-dimensional input matrix or “biosignal image” of the biosignal.HEARTio then processes the multi-dimensional input matrix/image toclassify the initial biosignals.

HEARTio is a multi-output model that has a single input, none of whichare demographic or biometric based. HEARTio employs an autoencoder stepthat can “correct” or “fill-in” any incoming biosignal. This means ifthere is significant noise or artifact intrinsic in the input biosignal,or if any leads or parts of leads are missing, HEARTio can reconstruct aviable image, such as a 12 lead ECG system, for example. HEARTio canaccomplish this with incomplete signal inputs. For example, HEARTio canreconstruct a 12 lead ECG even if there is only 1 viable input lead. RawOutputs given by the HEARTio deep learning model include and LAD FFR,“70%” Disease threshold, Hypertrophy, Morphology, MI location, ST-Tchanges, and Conduction disorders.

Training methodologies employed by the HEARTio deep learning model caninclude different ways of augmenting existing datasets. For example,stripping random segments/leads from the biosignal before inputting thebiosignal during the forward pass segment of backpropagation. HEARTiocan alter the biosignal, such as by increasing/decreasing the heart ratebefore input. Alternately and/or additionally, HEARTio can alter asensor configuration, such as by flipping the leads before input, orreorganizing the leads before input.

Adaptive weight losses changed after every epoch based on the change inperformance and loss magnitudes. Training involves organizing eachbiosignal into a specific “folder” that is associated with a specificoutput. During training, HEARTio will be inputted with various “folders”such that at the end of a “cycle”, each folder has been shown to HEARTioso there is no gap in training. (i.e. a rare output that is only seen 1×every 500 epochs or something). During training, any ECGs that representa “missing signal” with no useable information are dropped based on afrequency domain analysis. During training, any leads that represent a“missing signal” with no useable information are zero-ed out based on afrequency domain analysis Losses employed by the HEARTio deep learningmodel during training and evaluation. HEARTio has 4 major classes ofcustom-made loss functions that are continually weighed for each update.Loss functions include, for example, a weighed binary cross entropy, aweighed categorical cross entropy, a weighed log cosh, and a binned meanlog squared error.

Alternatively and/or additionally, HEARTio uses multiple semi-supervisedloss functions in order to learn from data where there might not be aclinical output, just the ECG signal itself. For example, HEARTio canuse a multi-task learning loss (MTL) that mandates that there is acorrelation (either positive or negative) between the latent space andevery one of the outputs. In other aspects, HEARTio can use asemi-supervised information loss (SSIL) that tries to have the modelfind an equilibrium between the information provided by each of theoutputs. According to some non-limiting aspects, the semi-supervisedloss and MTL losses can be added into an overall loss with someweighting. While the other losses (e.g., adaptive weight losses) can beused to train the model to make correct predictions on the trainingdata, the semi-supervised, amd MTL can make sure that the model isgeneralized and not overfitting to the training data.

As illustrated in FIGS. 5A-B and 6A-B, HEARTio can provide variousvisualizations employed by the platform. HEARTio can be device agnosticand configured to utilize any digital biosignal file coming from abiosignal device. If the only available file type is an image or pdf, arudimentary computer vision algorithm can be used to convert this datatype into a digital format. As such, HEARTio can use a full, 12-lead,ECG device or and single lead devices, including a wearable device, suchas a smart watch.

According to some non-limiting aspects, the present disclosurecontemplates a diagnostic tool, wherein the diagnostic tool includes: asensor for capturing at least one biosignal produced by a patient'sheart; and a computer device that implements a deep neural network thatis trained iteratively through machine learning to generate a predictionabout a heart condition of the patient, wherein, after the deep neuralnetwork is trained, the computer device is configured to: convert the atleast one biosignal to a multi-dimensional input matrix for the deepneural network generated from a number (N) of biosignals captured by thesensor, wherein each of the N biosignals is at least “T” seconds, andwherein N is greater than 1; and process the multi-dimensional inputmatrix through the deep neural network, wherein an output of the deepneural network from processing the multi-dimensional input matrixthrough the deep neural network corresponds to the prediction about theheart condition of the patient.

In some non-limiting aspects, the deep neural network is a DenseNetincluding a plurality of layers configured to receive inputs frompreceding layers of the plurality and generate outputs for proceedinglayers of the plurality, such that each layer of the plurality has acollective knowledge from all preceding layers of the plurality.

In some non-limiting aspects, the biosignal is an ECG signal, andwherein N is 12.

In some non-limiting aspects, the biosignal is an ECG signal, wherein Nis less than 12, and wherein the computer device further implements anautoencoder trained via machine learning to generate 12-N biosignalsbased, at least in part, on a reconstruction loss function.

In some non-limiting aspects, the reconstruction loss functioncalculates a squared difference between a fast Fourier transform (FFT)between an input of the sensor and an output of the autoencoder.

In some non-limiting aspects, the autoencoder includes: an encoderconfigured to perform a lossy compression of the at least one biosignalcaptured by the sensor, wherein an output of the lossy compression is alatent space representation; and a decoder configured to receive thelatent space representation from the encoder and convert the latentspace representation into a tensorform signal input to the DenseNet.

In some non-limiting aspects, the DenseNet is configured to generate afeature vector based, at least in part, on the tensorform signal.

In some non-limiting aspects, the DenseNet includes: a concatenationlayer configured to concatenate the feature vector and the latent spacerepresentation into a concatenated feature vector; and a classifierclayer configured to generate outputs based, at least in part, on theconcatenated feature vector, and wherein the prediction is generatedbased, at least in part, on the outputs of the classifier.

In some non-limiting aspects, the output includes at least one of a beatclassifications, a rhythm classification, and a coronary condition, orcombinations thereof.

In some non-limiting aspects, the coronary condition includes at leastone of: a Myocardial Infarction (MI), a risk of a Major AdverseCardiovascular Event (MACE), a coronary artery disease (CAD), a leftanterior descending (LAD) coronary artery fractional flow reserve (FFR),an atherosclerotic cardiovascular disease (ACVD), cardiac hypertrophy,ventricle morphology, an abnormal ST-T wave, a conduction disorder, anda “70%” disease threshold, or combinations thereof.

In some non-limiting aspects, wherein at least one biosignal is anelectroencephalogram (EEG).

In some non-limiting aspects, the sensor is a wearable device.

In some non-limiting aspects, T is greater than or equal to 5 second andless than or equal to 15 seconds.

In some non-limiting aspects, the diagnostic tool further includes adisplay coupled to the computer device, wherein the display isconfigured to visually represent the output of the deep neural networkand the prediction about the heart condition of the patient.

According to some non-limiting aspects, the present disclosurecontemplates a method including: training, with a computer system,iteratively through machine learning, a deep neural network to make aprediction about a heart condition of a patient; and after training thedeep neural network: capturing, with a sensor, at least one biosignalproduced by a patient's heart; converting, by the computer system, theat least one biosignal to an input matrix for the deep neural network,wherein the input matrix includes a multi-dimensional matrix generatedfrom a number (N) of biosignals of at least “T” seconds, where N isgreater than 1; and processing, by the computer system, themulti-dimensional input matrix through the deep neural network, whereinan output of the deep neural network from processing themulti-dimensional input matrix through the deep neural networkcorresponds to the prediction about the heart condition of the patient.

In some non-limiting aspects, the method further includes randomlyremoving at least one of the N biosignals from the multi-dimensionalinput matrix prior to processing the multi-dimensional input matrixthrough the deep neural network.

In some non-limiting aspects, the method further includes alteringeither the biosignal captured by the sensor or a sensor configurationprior to processing the multi-dimensional input matrix through the deepneural network.

In some non-limiting aspects, the processing is iterative, wherein thedeep neural network includes a loss algorithm, and the method furtherincludes: assessing, via the loss algorithm, a weight loss associatedwith each of the N biosignals in the multi-dimensional input matrixbased, at least in part, on a change in performance and/or a lossmagnitude; and changing the weight associated with each of the Nbiosignals for subsequent iterations based, at least in part, on theassessment.

In some non-limiting aspects, the loss function is selected from a groupconsisting of a weighted binary cross entropy, a weighted categoricalcross entropy, a weighted log cosh, and a binned mean log squared error.

In some non-limiting aspects, the loss function is semi-supervised andis either a multi-task learning loss (MTL) configured to correlatelatent space and a each of a plurality of outputs or a semi-supervisedinformation loss (SSIL) configured to find an equilibrium betweeninformation provided by each the output and a plurality of possibleoutputs.

In some non-limiting aspects, the method further includes organizing thesensor into one of a plurality of folders, wherein each of the pluralityof folders is associated with at least one of the plurality of possibleoutputs.

In some non-limiting aspects, the method further includes: assigning, bythe computer system, a corresponding label to each of the plurality ofoutputs; determining, by the computer system, that at least one outputof the plurality of outputs does not have a corresponding label; andcreating, by the computer system, a label corresponding to the at leastone output of the plurality of outputs.

According to some non-limiting aspects, the present disclosurecontemplates a computer system including one or more processor cores,wherein the one or more processor cores are configured to: train,iteratively through machine learning, a deep neural network to make aprediction about a heart condition of a patient; and after training thedeep neural network: receive, from a sensor, at least one ECG signalproduced by a patient's heart and captured by the sensor; convert the atleast one ECG signal to an input matrix for the deep neural network,wherein the input matrix includes a multi-dimensional [or multi-axis]matrix generated from N ECG signals of at least T seconds, where N isgreater than 1; and process the input matrix through the deep neuralnetwork, wherein an output of the deep neural network from processingthe input matrix through the deep neural network corresponds to theprediction about the heart condition of the patient.

The examples presented herein are intended to illustrate potential andspecific implementations of the present invention. It can be appreciatedthat the examples are intended primarily for purposes of illustration ofthe invention for those skilled in the art. No particular aspect oraspects of the examples are necessarily intended to limit the scope ofthe present invention. Further, it is to be understood that the figuresand descriptions of the present invention have been simplified toillustrate elements that are relevant for a clear understanding of thepresent invention, while eliminating, for purposes of clarity, otherelements. While various aspects have been described herein, it should beapparent that various modifications, alterations, and adaptations tothose aspects may occur to persons skilled in the art with attainment ofat least some of the advantages. For example, functions explicitlydescribed as performed by the previously disclosed diagnostic tool canbe claimed as a method independent of the diagnostic tool, itself.Likewise, it shall be appreciated that the previously discloseddiagnostic tool can be further configured and claimed to perform stepsexplicitly described in reference to the methods disclosed herein. Assuch, the disclosed embodiments are therefore intended to include allsuch modifications, alterations, and adaptations without departing fromthe scope of the aspects as set forth herein.

APPENDIX A

TABLE 4 Category & Sub-indexes Blockage LAD % LCX % RCA % LM % MI &History Acute MI Prior MI NSTEMI Prior GABG Prior PCI Beats Ventricularflutter wave Paced beat Atrial premature beat Ventricular escape beatFusion of ventricular and normal beat Nodal (junctional) premature beatLeft bundle branch block beat Normal beat Unclassifiable beatSupraventricular premature or ectopic beat (atrial or nodal) Rightbundle branch block beat Premature ventricular contraction Aberratedatrial premature beat Atrial escape beat Fusion of paced and normal beatNodal (junctional) escape beat Non-conducted P-wave (blocked APC) RhythmAtrial bigeminy Atrial fibrillation Atrial flutter Ventricular bigeminyFirst heart block Second heart block Idioventricular rhythm Normal sinusrhythm Nodal (A-V junctional) rhythm Paced rhythm Pre-excitation (WPW)Sinus bradycardia Supraventricular tachyarrhythmia Ventricular trigeminyVentricular flutter Ventricular tachycardia Noise MACE None MI StrokeSyncope Label-Overall Low-Mild Moderate Severe Binary Blockage LAD RCALCX LM Bloodtests Troponin Initial Troponin Peak CK peak CKMB peakComplications Cardiac Arrest Cardiogenic Shock Severe Heart Failure -Pulmonary Edema Extension of MI Ejection Fraction Ejection Fraction %Disease Significant Disease SPECT Segment 0 Segment 1 Segment 2 Segment3 Segment 4 Segment 5 Segment 6 Segment 7 Segment 8 Segment 9 Segment 10Segment 11 Segment 12 Segment 13 Segment 14 Segment 15 Segment 16Segment 17 Segment 18 Segment 19 Conduction Disorders Left AnteriorFascicular Block Incomplete Right Bundle Branch Block First Degree AVBlock Non-specific Intraventricular Conduction Disturbance (Block)Complete Right Bundle Branch Block Complete Left Bundle Branch BlockLeft Posterior Fascicular Block Wolf-Parkinson-White syndrome IncompleteLeft Bundle Branch Block Third Degree AV Block Second Degree AV BlockHypertrophy Left Ventricular Hypertrophy Left AtrialOverload/Enlargement Right Ventricular Hypertrophy Right AtrialOverload/Enlargement Septal Hypertrophy Location of MI inferiormyocardial infarction anteroseptal myocardial infarction inferolateralmyocardial infarction anterior myocardial infarction anterolateralmyocardial infarction subendocardial injury in anteroseptal leadslateral myocardial infarction subendocardial injury in anterolateralleads inferoposterolateral myocardial infarction inferoposteriormyocardial infarction subendocardial injury in inferior leadssubendocardial injury in lateral leads posterior myocardial infarctionsubendocardial injury in inferolateral leads Morphology abnormal QRSventricular premature complex non-specific ST depression voltagecriteria (QRS) for left ventricular hypertrophy Q waves present lowamplitude T-waves non-specific T-wave changes atrial premature complexprolonged PR interval inverted T-waves low QRS voltages in the frontaland horizontal leads high QRS voltage T-wave abnormality non-specific STelevation premature complex(es) ST-T Changes non-diagnostic Tabnormalities non-specific ST changes digitalis-effect long QT-intervalnon-specific ischemic ischemic in anterolateral leads ischemic ininferior leads ischemic in inferolateral leads ischemic in anteroseptalleads ischemic in lateral leads ST-T changes compatible with ventricularaneurysm electrolytic disturbance or drug (former EDIS) ischemic inanterior leads Ejection Fraction Binary Ejection Fraction Binary FFR LADFFR % FFR Binary LAD FFR Binary 70% Disease Significant Disease

APPENDIX B

TABLE 5 Model: “Encoder” Layer (type) Output Shape Param # input 1(InputLayer) (None, 1000, 12, 1) 0 gaussian dropout 1 (Gaussian (None,1000, 12, 1) 0 zero padding2d 1 (ZeroPaddin (None, 1004, 12, 1) 0 conv2d1 (Conv2D) (None, 500, 12, 32) 160 leaky re lu 1 (LeakyReLU) (None, 500,12, 32) 0 batch normalization 1 (Batch (None, 500, 12, 32) 128 zeropadding2d 2 (ZeroPaddin (None, 504, 12, 32) 0 conv2d 2 (Conv2D) (None,250, 12, 64) 10240 leaky re lu 2 (LeakyReLU) (None, 250, 12, 64) 0 batchnormalization 2 (Batch (None, 250, 12, 64) 256 zero padding2d 3(ZeroPaddin (None, 254, 12, 64) 0 conv2d 3 (Conv2D) (None, 125, 12, 96)30720 leaky re lu 3 (LeakyReLU) (None, 125, 12, 96) 0 batchnormalization 3 (Batch (None, 125, 12, 96) 384 zero padding2d 4(ZeroPaddin (None, 129, 12, 96) 0 conv2d 4 (Conv2D) (None, 63, 12, 128)61440 leaky re lu 4 (LeakyReLU) (None, 63, 12, 128) 0 batchnormalization 4 (Batch (None, 63, 12, 128) 512 zero padding2d 5(ZeroPaddin (None, 67, 12, 128) 0 conv2d 5 (Conv2D) (None, 32, 12, 160)102400 leaky re lu 5 (LeakyReLU) (None, 32, 12, 160) 0 batchnormalization 5 (Batch (None, 32, 12, 160) 640 zero padding2d 6(ZeroPaddin (None, 36, 12, 160) 0 conv2d 6 (Conv2D) (None, 16, 12, 192)153600 leaky re lu 6 (LeakyReLU) (None, 16, 12, 192) 0 batchnormalization 6 (Batch (None, 16, 12, 192) 768 zero padding2d 7(ZeroPaddin (None, 20, 12, 192) 0 conv2d 7 (Conv2D) (None, 8, 12, 224)215040 leaky re lu 7 (LeakyReLU) (None, 8, 12, 224) 0 batchnormalization 7 (Batch (None, 8, 12, 224) 896 zero padding2d 8(ZeroPaddin (None, 12, 12, 224) 0 conv2d 8 (Conv2D) (None, 4, 12, 256)286720 leaky re lu 8 (LeakyReLU) (None, 4, 12, 256) 0 batchnormalization 8 (Batch (None, 4, 12, 256) 1024 flatten 1 (Flatten)(None, 12288) 0 dense 1 (Dense) (None, 1024) 12582912 leaky re lu 9(LeakyReLU) (None, 1024) 0 batch normalization 9 (Batch (None, 1024)4096 Total params: 13,451,936 Trainable params: 13,447,584 Non-trainableparams: 4,352

APPENDIX C

TABLE 6 Model: “Decoder” Layer (type) Output Shape Param # input 2(InputLayer) (None, 1024) 0 dense 2 (Dense) (None, 12288) 12582912 leakyre lu 10 (LeakyReLU) (None, 12288) 0 batch normalization 10 (Bate (None,12288) 49152 reshape 1 (Reshape) (None, 4, 12, 256) 0 conv2d transpose 1(Conv2DTr (None, 10, 12, 224) 229600 leaky re lu 11 (LeakyReLU) (None,10, 12, 224) 0 cropping2d 1 (Cropping2D) (None, 8, 12, 224) 0 batchnormalization 11 (Bate (None, 8, 12, 224) 896 conv2d transpose 2(Conv2DTr (None, 18, 12, 192) 172224 leaky re lu 12 (LeakyReLU) (None,18, 12, 192) 0 cropping2d 2 (Cropping2D) (None, 16, 12, 192) 0 batchnormalization 12 (Bate (None, 16, 12, 192) 768 conv2d transpose 3(Conv2DTr (None, 34, 12, 160) 123040 leaky re lu 13 (LeakyReLU) (None,34, 12, 160) 0 cropping2d 3 (Cropping2D) (None, 32, 12, 160) 0 batchnormalization 13 (Bate (None, 32, 12, 160) 640 conv2d transpose 4(Conv2DTr (None, 66, 12, 128) 82048 leaky re lu 14 (LeakyReLU) (None,66, 12, 128) 0 cropping2d 4 (Cropping2D) (None, 64, 12, 128) 0 batchnormalization 14 (Bate (None, 64, 12, 128) 512 conv2d transpose 5(Conv2DTr (None, 130, 12, 96) 49248 leaky re lu 15 (LeakyReLU) (None,130, 12, 96) 0 cropping2d 5 (Cropping2D) (None, 128, 12, 96) 0 batchnormalization 15 (Bate (None, 128, 12, 96) 384 conv2d transpose 6(Conv2DTr (None, 258, 12, 64) 24640 leaky re lu 16 (LeakyReLU) (None,258, 12, 64) 0 cropping2d 6 (Cropping2D) (None, 256, 12, 64) 0 batchnormalization 16 (Bate (None, 256, 12, 64) 256 conv2d transpose 7(Conv2DTr (None, 514, 12, 32) 8224 leaky re lu 17 (LeakyReLU) (None,514, 12, 32) 0 cropping2d 7 (Cropping2D) (None, 512, 12, 32) 0 batchnormalization 17 (Bate (None, 512, 12, 32) 128 conv2d transpose 8(Conv2DTr (None, 1026, 12, 1) 129 cropping2d 8 (Cropping2D) (None, 1000,12, 1) 0 Total params: 13,324,801 Trainable params: 13,298,433

APPENDIX D

TABLE 8 Model: ″Densenet″ Layer (type) Output Shape Param # Connected toinput 1 (InputLayer) (None, 1000, 12, 1) 0 zero padding2d 1(ZeroPadding2D (None, 1006, 12, 1) 0 input 1[0][0] conv1/conv (Conv2D)(None, 500, 12, 64) 448 zero padding2d 1[0][0] conv1/bn(BatchNormalization) (None, 500, 12, 64) 256 conv1/conv[0][0] conv1/relu(Activation) (None, 500, 12, 64) 0 conv1/bn [0][0] zero padding2d 2(ZeroPadding2D (None, 502, 12, 64) 0 conv1/relu[0][0] pool1(MaxPooling2D) (None, 250, 12, 64) 0 zero padding2d 2[0][0] conv2 block10 bn (BatchNormali (None, 250, 12, 64) 256 pool1[0][0] conv2 block1 0relu (Activation (None, 250, 12, 64) 0 conv2 block1 0 bn[0][0] conv2block1 1 conv (Conv2D) (None, 250, 12, 128) 8192 conv2 block1 0relu[0][0] conv2 block1 1 bn (BatchNormali (None, 250, 12, 128) 512conv2 block1 1 conv[0][0] conv2 block1 1 relu (Activation (None, 250,12, 128) 0 conv2 block1 1 bn[0][0] conv2 block1 2 conv (Conv2D) (None,250, 12, 32) 12288 conv2 block1 1 relu[0][0] conv2 block1 concat(Concatenat (None, 250, 12, 96) 0 pool1[0][0] conv2 block1 2 conv[0][0]conv2 block2 0 bn (BatchNormali (None, 250, 12, 96) 384 conv2 block1concat[0][0] conv2 block2 0 relu (Activation (None, 250, 12, 96) 0 conv2block2 0 bn[0][0] conv2 block2 1 conv (Conv2D) (None, 250, 12, 128)12288 conv2 block2 0 relu[0][0] conv2 block2 1 bn (BatchNormali (None,250, 12, 128) 512 conv2 block2 1 conv[0][0] conv2 block2 1 relu(Activation (None, 250, 12, 128) 0 conv2 block2 1 bn[0][0] conv2 block22 conv (Conv2D) (None, 250, 12, 32) 12288 conv2 block2 1 relu[0][0]conv2 block2 concat (Concatenat (None, 250, 12, 128) 0 conv2 block1concat[0][0] conv2 block2 2 conv[0][0] conv2 block3 0 bn (BatchNormali(None, 250, 12, 128) 512 conv2 block2 concat[0][0] conv2 block3 0 relu(Activation (None, 250, 12, 128) 0 conv2 block3 0 bn[0][0] conv2 block31 conv (Conv2D) (None, 250, 12, 128) 16384 conv2 block3 0 relu[0][0]conv2 block3 1 bn (BatchNormali (None, 250, 12, 128) 512 conv2 block3 1conv[0][0] conv2 block3 1 relu (Activation (None, 250, 12, 128) 0 conv2block2 1 bn[0][0] conv2 block3 2 conv (Conv2D) (None, 250, 12, 32) 12288conv2 block3 1 relu[0][0] conv2 block3 concat (Concatenat (None, 250,12, 160) 0 conv2 block2 concat[0][0] conv2 block3 2 conv[0][0] conv2block4 0 bn (BatchNormali (None, 250, 12, 160) 640 conv2 block3concat[0][0] conv2 block4 0 relu (Activation (None, 250, 12, 160) 0conv2 block4 0 bn[0][0] conv2 block4 1 conv (Conv2D) (None, 250, 12,128) 20480 conv2 block4 0 relu[0][0] conv2 block4 1 bn (BatchNormali(None, 250, 12, 128) 512 conv2 block4 1 conv[0][0] conv2 block4 1 relu(Activation (None, 250, 12, 128) 0 conv2 block4 1 bn[0][0] conv2 block42 conv (Conv2D) (None, 250, 12, 32) 12288 conv2 block4 1 relu[0][0]conv2 block4 concat (Concatenat (None, 250, 12, 192) 0 conv2 block3concat[0][0] conv2 block4 2 conv[0][0] conv2 block5 0 bn (BatchNormali(None, 250, 12, 192) 768 conv2 block4 concat[0][0] conv2 block5 0 relu(Activation (None, 250, 12, 192) 0 conv2 block5 0 bn[0][0] conv2 block51 conv (Conv2D) (None, 250, 12, 128) 24576 conv2 block5 0 relu[0][0]conv2 block5 1 bn (BatchNormali (None, 250, 12, 128) 512 conv2 block5 1conv[0][0] conv2 block5 1 relu (Activation (None, 250, 12, 128) 0 conv2block5 1 bn[0][0] conv2 block5 2 conv (Conv2D) (None, 250, 12, 32) 12288conv2 block5 1 relu[0][0] conv2 block5 concat (Concatenat (None, 250,12, 224) 0 conv2 block4 concat[0][0] conv2 block5 2 conv[0][0] conv2block6 0 bn (BatchNormali (None, 250, 12, 224) 896 conv2 block5concat[0][0] conv2 block6 0 relu (Activation (None, 250, 12, 224) 0conv2 block6 0 bn[0][0] conv2 block6 1 conv (Conv2D) (None, 250, 12,128) 28672 conv2 block6 0 relu[0][0] conv2 block6 1 bn (BatchNormali(None, 250, 12, 128) 512 conv2 block6 1 conv[0][0] conv2 block6 1 relu(Activation (None, 250, 12, 128) 0 conv2 block6 1 bn[0][0] conv2 block62 conv (Conv2D) (None, 250, 12, 32) 12288 conv2 block6 1 relu[0][0]conv2 block6 concat (Concatenat (None, 250, 12, 256) 0 conv2 block5concat[0][0] conv2 block6 2 conv[0][0] pool2 bn (BatchNormalization)(None, 250, 12, 256) 1024 conv2 block6 concat[0][0] pool2 relu(Activation) (None, 250, 12, 256) 0 pool2 bn[0][0] pool2 conv (Conv2D)(None, 250, 12, 128) 32768 pool2 relu[0][0] pool2 pool(AveragePooling2D) (None, 125, 12, 128) 0 pool2 conv[0][0] conv3 block10 bn (BatchNormali (None, 125, 12, 128) 512 pool2 pool[0][0] conv3block1 0 relu (Activation (None, 125, 12, 128) 0 conv3 block1 0 bn[0][0]conv3 block1 1 conv (Conv2D) (None, 125, 12, 128) 16384 conv3 block1 0relu[0][0] conv3 block1 1 bn (BatchNormali (None, 125, 12, 128) 512conv3 block1 1 conv[0][0] conv3 block1 1 relu (Activation (None, 125,12, 128) 0 conv3 block1 1 bn[0][0] conv3 block1 2 conv (Conv2D) (None,125, 12, 32) 12288 conv3 block1 1 relu[0][0] conv3 block1 concat(Concatenat (None, 125, 12, 160) 0 pool2 pool[0][0] conv3 block1 2conv[0][0] conv3 block2 0 bn (BatchNormali (None, 125, 12, 160) 640conv3 block1 concat[0][0] conv3 block2 0 relu (Activation (None, 125,12, 160) 0 conv3 block2 0 bn[0][0] conv3 block2 1 conv (Conv2D) (None,125, 12, 128) 20480 conv3 block2 0 relu[0][0] conv3 block2 1 bn(BatchNormali (None, 125, 12, 128) 512 conv3 block2 1 conv[0][0] conv3block2 1 relu (Activation (None, 125, 12, 128) 0 conv3 block2 1 bn[0][0]conv3 block2 2 conv (Conv2D) (None, 125, 12, 32) 12288 conv3 block2 1relu[0][0] conv3 block2 concat (Concatenat (None, 125, 12, 192) 0 conv3block1 concat[0][0] conv3 block2 2 conv[0][0] conv3 block3 0 bn(BatchNormali (None, 125, 12, 192) 768 conv3 block2 concat[0][0] conv3block3 0 relu (Activation (None, 125, 12, 192) 0 conv3 block3 0 bn[0][0]conv3 block3 1 conv (Conv2D) (None, 125, 12, 128) 24576 conv3 block3 0relu[0][0] conv3 block3 1 bn (BatchNormali (None, 125, 12, 128) 512conv3 block3 1 conv[0][0] conv3 block3 1 relu (Activation (None, 125,12, 128) 0 conv3 block3 1 bn[0][0] conv3 block3 2 conv (Conv2D) (None,125, 12, 32) 12288 conv3 block3 1 relu[0][0] conv3 block3 concat(Concatenat (None, 125, 12, 224) 0 conv3 block2 concat[0][0] conv3block3 2 conv[0][0] conv3 block4 0 bn (BatchNormali (None, 125, 12, 224)896 conv3 block3 concat[0][0] conv3 block4 0 relu (Activation (None,125, 12, 224) 0 conv3 block4 0 bn[0][0] conv3 block4 1 conv (Conv2D)(None, 125, 12, 128) 28672 conv3 block4 0 relu[0][0] conv3 block4 1 bn(BatchNormali (None, 125, 12, 128) 512 conv3 block4 1 conv[0][0] conv3block4 1 relu (Activation (None, 125, 12, 128) 0 conv3 block4 1 bn[0][0]conv3 block4 2 conv (Conv2D) (None, 125, 12, 32) 12288 conv3 block4 1relu[0][0] conv3 block4 concat (Concatenat (None, 125, 12, 256) 0 conv3block3 concat[0][0] conv3 block4 2 conv[0][0] conv3 block5 0 bn(BatchNormali (None, 125, 12, 256) 1024 conv3 block4 concat[0][0] conv3block5 0 relu (Activation (None, 125, 12, 256) 0 conv3 block5 0 bn[0][0]conv3 block5 1 conv (Conv2D) (None, 125, 12, 128) 32768 conv3 block5 0relu[0][0] conv3 block5 1 bn (BatchNormali (None, 125, 12, 128) 512conv3 block5 1 conv[0][0] conv3 block5 1 relu (Activation (None, 125,12, 128) 0 conv3 block5 1 bn[0][0] conv3 block5 2 conv (Conv2D) (None,125, 12, 32) 12288 conv3 block5 1 relu[0][0] conv3 block5 concat(Concatenat (None, 125, 12, 288) 0 conv3 block4 concat[0][0] conv3block5 2 conv[0][0] conv3 block6 0 bn (BatchNormali (None, 125, 12, 288)1152 conv3 block5 concat[0][0] conv3 block6 0 relu (Activation (None,125, 12, 288) 0 conv3 block6 0 bn[0][0] conv3 block6 1 conv (Conv2D)(None, 125, 12, 128) 36864 conv3 block6 0 relu[0][0] conv3 block6 1 bn(BatchNormali (None, 125, 12, 128) 512 conv3 block6 1 conv[0][0] conv3block6 1 relu (Activation (None, 125, 12, 128) 0 conv3 block6 1 bn[0][0]conv3 block6 2 conv (Conv2D) (None, 125, 12, 32) 12288 conv3 block6 1relu[0][0] conv3 block6 concat (Concatenat (None, 125, 12, 320) 0 conv3block5 concat[0][0] conv3 block6 2 conv[0][0] conv3 block7 0 bn(BatchNormali (None, 125, 12, 320) 1280 conv3 block6 concat[0][0] conv3block7 0 relu (Activation (None, 125, 12, 320) 0 conv3 block7 0 bn[0][0]conv3 block7 1 conv (Conv2D) (None, 125, 12, 128) 40960 conv3 block7 0relu[0][0] conv3 block7 1 bn (BatchNormali (None, 125, 12, 128) 512conv3 block7 1 conv[0][0] conv3 block7 I relu (Activation (None, 125,12, 128) 0 conv3 block7 1 bn[0][0] conv3 block7 2 conv (Conv2D) (None,125, 12, 32) 12288 conv3 block7 1 relu[0][0] conv3 block7 concat(Concatenat (None, 125, 12, 352) 0 conv3 block6 concat[0][0] conv3block7 2 conv[0][0] conv3 block8 0 bn (BatchNormali (None, 125, 12, 352)1408 conv3 block7 concat[0][0] conv3 block8 0 relu (Activation (None,125, 12, 352) 0 conv3 block8 0 bn[0][0] conv3 block8 1 conv (Conv2D)(None, 125, 12, 128) 45056 conv3 block8 0 relu[0][0] conv3 block8 1 bn(BatchNormali (None, 125, 12, 128) 512 conv3 block8 1 conv[0][0] conv3block8 1 relu (Activation (None, 125, 12, 128) 0 conv3 block8 1 bn[0][0]conv3 block8 2 conv (Conv2D) (None, 125, 12, 32) 12288 conv3 block8 1relu[0][0] conv3 block8 concat (Concatenat (None, 125, 12, 384) 0 conv3block7 concat[0][0] conv3 block8 2 conv[0][0] conv3 block9 0 bn(BatchNormali (None, 125, 12, 384) 1536 conv3 block8 concat[0][0] conv3block9 0 relu (Activation (None, 125, 12, 384) 0 conv3 block9 0 bn[0][0]conv3 block9 1 conv (Conv2D) (None, 125, 12, 128) 49152 conv3 block9 0relu[0][0] conv3 block9 1 bn (BatchNormali (None, 125, 12, 128) 512conv3 block9 1 conv[0][0] conv3 block9 1 relu (Activation (None, 125,12, 128) 0 conv3 block9 1 bn[0][0] conv3 block9 2 conv (Conv2D) (None,125, 12, 32) 12288 conv3 block9 1 relu[0][0] conv3 block9 concat(Concatenat (None, 125, 12, 416) 0 conv3 block8 concat[0][0] conv3block9 2 conv[0][0] conv3 block10 0 bn (BatchNormal (None, 125, 12, 416)1664 conv3 block9 concat[0][0] conv3 block10 0 relu (Activatio (None,125, 12, 416) 0 conv3 block10 0 bn[0][0] conv3 block10 1 conv (Conv2D)(None, 125, 12, 128) 53248 conv3 block10 0 relu[0][0] conv3 block10 1 bn(BatchNormal (None, 125, 12, 128) 512 conv3 block10 1 conv[0][0] conv3block10 1 relu (Activatio (None, 125, 12, 128) 0 conv3 block10 1bn[0][0] conv3 block10 2 conv (Conv2D) (None, 125, 12, 32) 12288 conv3block10 1 relu[0][0] conv3 block10 concat (Concatena (None, 125, 12,448) 0 conv3 block9 concat[0][0] conv3 block10 2 conv[0][0] conv3block11 0 bn (BatchNormal (None, 125, 12, 448) 1792 conv3 block10concat[0][0] conv3 block11 0 relu (Activatio (None, 125, 12, 448) 0conv3 block11 0 bn[0][0] conv3 block11 1 conv (Conv2D) (None, 125, 12,128) 57344 conv3 block11 0 relu[0][0] conv3 block11 1 bn (BatchNormal(None, 125, 12, 128) 512 conv3 block11 1 conv[0][0] conv3 block11 1 relu(Activatio (None, 125, 12, 128) 0 conv3 block11 1 bn[0][0] conv3 block112 conv (Conv2D) (None, 125, 12, 32) 12288 conv3 block11 1 relu[0][0]conv3 block11 concat (Concatena (None, 125, 12, 480) 0 conv3 block10concat[0][0] conv3 block11 2 conv[0][0] conv3 block12 0 bn (BatchNormal(None, 125, 12, 480) 1920 conv3 block11 concat[0][0] conv3 block12 0relu (Activatio (None, 125, 12, 480) 0 conv3 block12 0 bn[0][0] conv3block12 1 conv (Conv2D) (None, 125, 12, 128) 61440 conv3 block12 0relu[0][0] conv3 block12 1 bn (BatchNormal (None, 125, 12, 128) 512conv3 block12 1 conv[0][0] conv3 block12 1 relu (Activatio (None, 125,12, 128) 0 conv3 block12 1 bn[0][0] conv3 block12 2 conv (Conv2D) (None,125, 12, 32) 12288 conv3 block12 1 relu[0][0] conv3 block12 concat(Concatena (None, 125, 12, 512) 0 conv3 block11 concat[0][0] conv3block12 2 conv[0][0] pool3 bn (BatchNormalization) (None, 125, 12, 512)2048 conv3 block12 concat[0][0] pool3 relu (Activation) (None, 125, 12,512) 0 pool3 bn[0][0] pool3 conv (Conv2D) (None, 125, 12, 256) 131072pool3 relu[0][0] pool3 pool (AveragePooling2D) (None, 62, 12, 256) 0pool3 conv[0][0] conv4 block1 0 bn (BatchNormali (None, 62, 12, 256)1024 pool3 pool[0][0] conv4 block1 0 relu (Activation (None, 62, 12,256) 0 conv4 block1 0 bn[0][0] conv4 block1 1 conv (Conv2D) (None, 62,12, 128) 32768 conv4 block1 0 relu[0][0] conv4 block1 1 bn (BatchNormali(None, 62, 12, 128) 512 conv4 block1 1 conv[0][0] conv4 block1 1 relu(Activation (None, 62, 12, 128) 0 conv4 block1 1 bn[0][0] conv4 block1 2conv (Conv2D) (None, 62, 12, 32) 12288 conv4 block1 1 relu[0][0] conv4block1 concat (Concatenat (None, 62, 12, 288) 0 pool3 pool[0][0] conv4block1 2 conv[0][0] conv4 block2 0 bn (BatchNormali (None, 62, 12, 288)1152 conv4 block1 concat[0][0] conv4 block2 0 relu (Activation (None,62, 12, 288) 0 conv4 block2 0 bn[0][0] conv4 block2 1 conv (Conv2D)(None, 62, 12, 128) 36864 conv4 block2 0 relu[0][0] conv4 block2 1 bn(BatchNormali (None, 62, 12, 128) 512 conv4 block2 1 conv[0][0] conv4block2 1 relu (Activation (None, 62, 12, 128) 0 conv4 block2 1 bn[0][0]conv4 block2 2 conv (Conv2D) (None, 62, 12, 32) 12288 conv4 block2 1relu[0][0] conv4 block2 concat (Concatenat (None, 62, 12, 320) 0 conv4block1 concat[0][0] conv4 block2 2 conv[0][0] conv4 block3 0 bn(BatchNormali (None, 62, 12, 320) 1280 conv4 block2 concat[0][0] conv4block3 0 relu (Activation (None, 62, 12, 320) 0 conv4 block3 0 bn[0][0]conv4 block3 1 conv (Conv2D) (None, 62, 12, 128) 40960 conv4 block3 0relu[0][0] conv4 block3 1 bn (BatchNormali (None, 62, 12, 128) 512 conv4block3 1 conv[0][0] conv4 block3 1 relu (Activation (None, 62, 12, 128)0 conv4 block3 1 bn[0][0] conv4 block3 2 conv (Conv2D) (None, 62, 12,32) 12288 conv4 block3 1 relu[0][0] conv4 block3 concat (Concatenat(None, 62, 12, 352) 0 conv4 block2 concat[0][0] conv4 block3 2conv[0][0] conv4 block4 0 bn (BatchNormali (None, 62, 12, 352) 1408conv4 block3 concat[0][0] conv4 block4 0 relu (Activation (None, 62, 12,352) 0 conv4 block4 0 bn[0][0] conv4 block4 1 conv (Conv2D) (None, 62,12, 128) 45056 conv4 block4 0 relu[0][0] conv4 block4 1 bn (BatchNormali(None, 62, 12, 128) 512 conv4 block4 1 conv[0][0] conv4 block4 1 relu(Activation (None, 62, 12, 128) 0 conv4 block4 1 bn[0][0] conv4 block4 2conv (Conv2D) (None, 62, 12, 32) 12288 conv4 block4 1 relu[0][0] conv4block4 concat (Concatenat (None, 62, 12, 384) 0 conv4 block3concat[0][0] conv4 block4 2 conv[0][0] conv4 block5 0 bn (BatchNormali(None, 62, 12, 384) 1536 conv4 block4 concat[0][0] conv4 block5 0 relu(Activation (None, 62, 12, 384) 0 conv4 block5 0 bn[0][0] conv4 block5 1conv (Conv2D) (None, 62, 12, 128) 49152 conv4 block5 0 relu[0][0] conv4block5 1 bn (BatchNormali (None, 62, 12, 128) 512 conv4 block5 1conv[0][0] conv4 block5 1 relu (Activation (None, 62, 12, 128) 0 conv4block5 1 bn[0][0] conv4 block5 2 conv (Conv2D) (None, 62, 12, 32) 12288conv4 block5 1 relu[0][0] conv4 block5 concat (Concatenat (None, 62, 12,416) 0 conv4 block4 concat[0][0] conv4 block5 2 conv[0][0] conv4 block60 bn (BatchNormali (None, 62, 12, 416) 1664 conv4 block5 concat[0][0]conv4 block6 0 relu (Activation (None, 62, 12, 416) 0 conv4 block6 0bn[0][0] conv4 block6 1 conv (Conv2D) (None, 62, 12, 128) 53248 conv4block6 0 relu[0][0] conv4 block6 1 bn (BatchNormali (None, 62, 12, 128)512 conv4 block6 1 conv[0][0] conv4 block6 1 relu (Activation (None, 62,12, 128) 0 conv4 block6 1 bn[0][0] conv4 block6 2 conv (Conv2D) (None,62, 12, 32) 12288 conv4 block6 1 relu[0][0] conv4 block6 concat(Concatenat (None, 62, 12, 448) 0 conv4 block5 concat[0][0] conv4 block62 conv[0][0] conv4 block7 0 bn (BatchNormali (None, 62, 12, 448) 1792conv4 block6 concat[0][0] conv4 block7 0 relu (Activation (None, 62, 12,448) 0 conv4 block7 0 bn[0][0] conv4 block7 1 conv (Conv2D) (None, 62,12, 128) 57344 conv4 block7 0 relu[0][0] conv4 block7 1 bn (BatchNormali(None, 62, 12, 128) 512 conv4 block7 1 conv[0][0] conv4 block7 I relu(Activation (None, 62, 12, 128) 0 conv4 block7 1 bn[0][0] conv4 block7 2conv (Conv2D) (None, 62, 12, 32) 12288 conv4 block7 1 relu[0][0] conv4block7 concat (Concatenat (None, 62, 12, 480) 0 conv4 block6concat[0][0] conv4 block7 2 conv[0][0] conv4 block8 0 bn (BatchNormali(None, 62, 12, 480) 1920 conv4 block7 concat[0][0] conv4 block8 0 relu(Activation (None, 62, 12, 480) 0 conv4 block8 0 bn[0][0] conv4 block8 1conv (Conv2D) (None, 62, 12, 128) 61440 conv4 block8 0 relu[0][0] conv4block8 1 bn (BatchNormali (None, 62, 12, 128) 512 conv4 block8 1conv[0][0] conv4 block8 1 relu (Activation (None, 62, 12, 128) 0 conv4block8 1 bn[0][0] conv4 block8 2 conv (Conv2D) (None, 62, 12, 32) 12288conv4 block8 1 relu[0][0] conv4 block8 concat (Concatenat (None, 62, 12,512) 0 conv4 block7 concat[0][0] conv4 block8 2 conv[0][0] conv4 block90 bn (BatchNormali (None, 62, 12, 512) 2048 conv4 block8 concat[0][0]conv4 block9 0 relu (Activation (None, 62, 12, 512) 0 conv4 block9 0bn[0][0] conv4 block9 1 conv (Conv2D) (None, 62, 12, 128) 65536 conv4block9 0 relu[0][0] conv4 block9 1 bn (BatchNormali (None, 62, 12, 128)512 conv4 block9 1 conv[0][0] conv4 block9 1 relu (Activation (None, 62,12, 128) 0 conv4 block9 1 bn[0][0] conv4 block9 2 conv (Conv2D) (None,62, 12, 32) 12288 conv4 block9 1 relu[0][0] conv4 block9 concat(Concatenat (None, 62, 12, 544) 0 conv4 block8 concat[0][0] conv4 block92 conv[0][0] conv4 block10 0 bn (BatchNormal (None, 62, 12, 544) 2176conv4 block9 concat[0][0] conv4 block10 0 relu (Activatio (None, 62, 12,544) 0 conv4 block10 0 bn[0][0] conv4 block10 1 conv (Conv2D) (None, 62,12, 128) 69632 conv4 block10 0 relu[0][0] conv4 block10 1 bn(BatchNormal (None, 62, 12, 128) 512 conv4 block10 1 conv[0][0] conv4block10 1 relu (Activatio (None, 62, 12, 128) 0 conv4 block10 1 bn[0][0]conv4 block10 2 conv (Conv2D) (None, 62, 12, 32) 12288 conv4 block10 1relu[0][0] conv4 block10 concat (Concatena (None, 62, 12, 576) 0 conv4block9 concat[0][0] conv4 block10 2 conv[0][0] conv4 block11 0 bn(BatchNormal (None, 62, 12, 576) 2304 conv4 block10 concat[0][0] conv4block11 0 relu (Activatio (None, 62, 12, 576) 0 conv4 block11 0 bn[0][0]conv4 block11 1 conv (Conv2D) (None, 62, 12, 128) 73728 conv4 block11 0relu[0][0] conv4 block11 1 bn (BatchNormal (None, 62, 12, 128) 512 conv4block11 1 conv[0][0] conv4 block11 1 relu (Activatio (None, 62, 12, 128)0 conv4 block11 1 bn[0][0] conv4 block11 2 conv (Conv2D) (None, 62, 12,32) 12288 conv4 block11 1 relu[0][0] conv4 block11 concat (Concatena(None, 62, 12, 608) 0 conv4 block10 concat[0][0] conv4 block11 2conv[0][0] conv4 block12 0 bn (BatchNormal (None, 62, 12, 608) 2432conv4 block11 concat[0][0] conv4 block12 0 relu (Activatio (None, 62,12, 608) 0 conv4 block12 0 bn[0][0] conv4 block12 1 conv (Conv2D) (None,62, 12, 128) 77824 conv4 block12 0 relu[0][0] conv4 block12 1 bn(BatchNormal (None, 62, 12, 128) 512 conv4 block12 1 conv[0][0] conv4block12 1 relu (Activatio (None, 62, 12, 128) 0 conv4 block12 1 bn[0][0]conv4 block12 2 conv (Conv2D) (None, 62, 12, 32) 12288 conv4 block12 1relu[0][0] conv4 block12 concat (Concatena (None, 62, 12, 640) 0 conv4block11 concat[0][0] conv4 block12 2 conv[0][0] conv4 block13 0 bn(BatchNormal (None, 62, 12, 640) 2560 conv4 block12 concat[0][0] conv4block13 0 relu (Activatio (None, 62, 12, 640) 0 conv4 block13 0 bn[0][0]conv4 block13 1 conv (Conv2D) (None, 62, 12, 128) 81920 conv4 block13 0relu[0][0] conv4 block13 1 bn (BatchNormal (None, 62, 12, 128) 512 conv4block13 1 conv[0][0] conv4 block13 1 relu (Activatio (None, 62, 12, 128)0 conv4 block13 1 bn[0][0] conv4 block13 2 conv (Conv2D) (None, 62, 12,32) 12288 conv4 block13 1 relu[0][0] conv4 block13 concat (Concatena(None, 62, 12, 672) 0 conv4 block12 concat[0][0] conv4 block13 2conv[0][0] conv4 block14 0 bn (BatchNormal (None, 62, 12, 672) 2688conv4 block13 concat[0][0] conv4 block14 0 relu (Activatio (None, 62,12, 672) 0 conv4 block14 0 bn[0][0] conv4 block14 1 conv (Conv2D) (None,62, 12, 128) 86016 conv4 block14 0 relu[0][0] conv4 block14 1 bn(BatchNormal (None, 62, 12, 128) 512 conv4 block14 1 conv[0][0] conv4block14 1 relu (Activatio (None, 62, 12, 128) 0 conv4 block14 1 bn[0][0]conv4 block14 2 conv (Conv2D) (None, 62, 12, 32) 12288 conv4 block14 1relu[0][0] conv4 block14 concat (Concatena (None, 62, 12, 704) 0 conv4block13 concat[0][0] conv4 block14 2 conv[0][0] conv4 block15 0 bn(BatchNormal (None, 62, 12, 704) 2816 conv4 block14 concat[0][0] conv4block15 0 relu (Activatio (None, 62, 12, 704) 0 conv4 block15 0 bn[0][0]conv4 block15 1 conv (Conv2D) (None, 62, 12, 128) 90112 conv4 block15 0relu[0][0] conv4 block15 1 bn (BatchNormal (None, 62, 12, 128) 512 conv4block15 1 conv[0][0] conv4 block15 1 relu (Activatio (None, 62, 12, 128)0 conv4 block15 1 bn[0][0] conv4 block15 2 conv (Conv2D) (None, 62, 12,32) 12288 conv4 block15 1 relu[0][0] conv4 block15 concat (Concatena(None, 62, 12, 736) 0 conv4 block14 concat[0][0] conv4 block15 2conv[0][0] conv4 block16 0 bn (BatchNormal (None, 62, 12, 736) 2944conv4 block15 concat[0][0] conv4 block16 0 relu (Activatio (None, 62,12, 736) 0 conv4 block16 0 bn[0][0] conv4 block16 1 conv (Conv2D) (None,62, 12, 128) 94208 conv4 block16 0 relu[0][0] conv4 block16 1 bn(BatchNormal (None, 62, 12, 128) 512 conv4 block16 1 conv[0][0] conv4block16 1 relu (Activatio (None, 62, 12, 128) 0 conv4 block16 1 bn[0][0]conv4 block16 2 conv (Conv2D) (None, 62, 12, 32) 12288 conv4 block16 1relu[0][0] conv4 block16 concat (Concatena (None, 62, 12, 768) 0 conv4block15 concat[0][0] conv4 block16 2 conv[0][0] conv4 block17 0 bn(BatchNormal (None, 62, 12, 768) 3072 conv4 block16 concat[0][0] conv4block17 0 relu (Activatio (None, 62, 12, 768) 0 conv4 block17 0 bn[0][0]conv4 block17 1 conv (Conv2D) (None, 62, 12, 128) 98304 conv4 block17 0relu[0][0] conv4 block17 1 bn (BatchNormal (None, 62, 12, 128) 512 conv4block17 1 conv[0][0] conv4 block17 1 relu (Activatio (None, 62, 12, 128)0 conv4 block17 1 bn[0][0] conv4 block17 2 conv (Conv2D) (None, 62, 12,32) 12288 conv4 block17 1 relu[0][0] conv4 block17 concat (Concatena(None, 62, 12, 800) 0 conv4 block16 concat[0][0] conv4 block17 2conv[0][0] conv4 block18 0 bn (BatchNormal (None, 62, 12, 800) 3200conv4 block17 concat[0][0] conv4 block18 0 relu (Activatio (None, 62,12, 800) 0 conv4 block18 0 bn[0][0] conv4 block18 1 conv (Conv2D) (None,62, 12, 128) 102400 conv4 block18 0 relu[0][0] conv4 block18 1 bn(BatchNormal (None, 62, 12, 128) 512 conv4 block18 1 conv[0][0] conv4block18 1 relu (Activatio (None, 62, 12, 128) 0 conv4 block18 1 bn[0][0]conv4 block18 2 conv (Conv2D) (None, 62, 12, 32) 12288 conv4 block18 1relu[0][0] conv4 block18 concat (Concatena (None, 62, 12, 832) 0 conv4block17 concat[0][0] conv4 block18 2 conv[0][0] conv4 block19 0 bn(BatchNormal (None, 62, 12, 832) 3328 conv4 block18 concat[0][0] conv4block19 0 relu (Activatio (None, 62, 12, 832) 0 conv4 block19 0 bn[0][0]conv4 block19 1 conv (Conv2D) (None, 62, 12, 128) 106496 conv4 block19 0relu[0][0] conv4 block19 1 bn (BatchNormal (None, 62, 12, 128) 512 conv4block19 1 conv[0][0] conv4 block19 1 relu (Activatio (None, 62, 12, 128)0 conv4 block19 1 bn[0][0] conv4 block19 2 conv (Conv2D) (None, 62, 12,32) 12288 conv4 block19 1 relu[0][0] conv4 block19 concat (Concatena(None, 62, 12, 864) 0 conv4 block18 concat[0][0] conv4 block19 2conv[0][0] conv4 block20 0 bn (BatchNormal (None, 62, 12, 864) 3456conv4 block19 concat[0][0] conv4 block20 0 relu (Activatio (None, 62,12, 864) 0 conv4 block20 0 bn[0][0] conv4 block20 1 conv (Conv2D) (None,62, 12, 128) 110592 conv4 block20 0 relu[0][0] conv4 block20 1 bn(BatchNormal (None, 62, 12, 128) 512 conv4 block20 1 conv[0][0] conv4block20 1 relu (Activatio (None, 62, 12, 128) 0 conv4 block20 1 bn[0][0]conv4 block20 2 conv (Conv2D) (None, 62, 12, 32) 12288 conv4 block20 1relu[0][0] conv4 block20 concat (Concatena (None, 62, 12, 896) 0 conv4block19 concat[0][0] conv4 block20 2 conv[0][0] conv4 block21 0 bn(BatchNormal (None, 62, 12, 896) 3584 conv4 block20 concat[0][0] conv4block21 0 relu (Activatio (None, 62, 12, 896) 0 conv4 block21 0 bn[0][0]conv4 block211 conv (Conv2D) (None, 62, 12, 128) 114688 conv4 block21 0relu[0][0] conv4 block211 bn (BatchNormal (None, 62, 12, 128) 512 conv4block21 1 conv[0][0] conv4 block211 relu (Activatio (None, 62, 12, 128)0 conv4 block21 1 bn[0][0] conv4 block21 2 conv (Conv2D) (None, 62, 12,32) 12288 conv4 block21 1 relu[0][0] conv4 block21 concat (Concatena(None, 62, 12, 928) 0 conv4 block20 concat[0][0] conv4 block21 2conv[0][0] conv4 block22 0 bn (BatchNormal (None, 62, 12, 928) 3712conv4 block21 concat[0][0] conv4 block22 0 relu (Activatio (None, 62,12, 928) 0 conv4 block22 0 bn[0][0] conv4 block22 1 conv (Conv2D) (None,62, 12, 128) 118784 conv4 block22 0 relu[0][0] conv4 block22 1 bn(BatchNormal (None, 62, 12, 128) 512 conv4 block22 1 conv[0][0] conv4block22 1 relu (Activatio (None, 62, 12, 128) 0 conv4 block22 1 bn[0][0]conv4 block22 2 conv (Conv2D) (None, 62, 12, 32) 12288 conv4 block22 1relu[0][0] conv4 block22 concat (Concatena (None, 62, 12, 960) 0 conv4block21 concat[0][0] conv4 block22 2 conv[0][0] conv4 block23 0 bn(BatchNormal (None, 62, 12, 960) 3840 conv4 block22 concat[0][0] conv4block23 0 relu (Activatio (None, 62, 12, 960) 0 conv4 block23 0 bn[0][0]conv4 block23 1 conv (Conv2D) (None, 62, 12, 128) 122880 conv4 block23 0relu[0][0] conv4 block23 1 bn (BatchNormal (None, 62, 12, 128) 512 conv4block23 1 conv[0][0] conv4 block23 1 relu (Activatio (None, 62, 12, 128)0 conv4 block23 1 bn[0][0] conv4 block23 2 conv (Conv2D) (None, 62, 12,32) 12288 conv4 block23 1 relu[0][0] conv4 block23 concat (Concatena(None, 62, 12, 992) 0 conv4 block22 concat[0][0] conv4 block23 2conv[0][0] conv4 block24 0 bn (BatchNormal (None, 62, 12, 992) 3968conv4 block23 concat[0][0] conv4 block24 0 relu (Activatio (None, 62,12, 992) 0 conv4 block24 0 bn[0][0] conv4 block24 1 conv (Conv2D) (None,62, 12, 128) 126976 conv4 block24 0 relu[0][0] conv4 block24 1 bn(BatchNormal (None, 62, 12, 128) 512 conv4 block24 1 conv[0][0] conv4block24 1 relu (Activatio (None, 62, 12, 128) 0 conv4 block24 1 bn[0][0]conv4 block24 2 conv (Conv2D) (None, 62, 12, 32) 12288 conv4 block24 1relu[0][0] conv4 block24 concat (Concatena (None, 62, 12, 1024) 0 conv4block23 concat[0][0] conv4 block24 2 conv[0][0] pool4bn(BatchNormalization) (None, 62, 12, 1024) 4096 conv4 block24concat[0][0] pool4 relu (Activation) (None, 62, 12, 1024) 0 pool4bn[0][0] pool4 conv (Conv2D) (None, 62, 12, 512) 524288 pool4 relu[0][0]pool4 pool (AveragePooling2D) (None, 31, 12, 512) 0 pool4 conv[0][0]conv5 block1 0 bn (BatchNormali (None, 31, 12, 512) 2048 pool4pool[0][0] conv5 block1 0 relu (Activation (None, 31, 12, 512) 0 conv5block1 0 bn[0][0] conv5 block1 1 conv (Conv2D) (None, 31, 12, 128) 65536conv5 block1 0 relu[0][0] conv5 block1 1 bn (BatchNormali (None, 31, 12,128) 512 conv5 block1 1 conv[0][0] conv5 block1 1 relu (Activation(None, 31, 12, 128) 0 conv5 block1 1 bn[0][0] conv5 block1 2 conv(Conv2D) (None, 31, 12, 32) 12288 conv5 block1 1 relu[0][0] conv5 block1concat (Concatenat (None, 31, 12, 544) 0 pool4 pool[0][0] conv5 block1 2conv[0][0] conv5 block2 0 bn (BatchNormali (None, 31, 12, 544) 2176conv5 block1 concat[0][0] conv5 block2 0 relu (Activation (None, 31, 12,544) 0 conv5 block2 0 bn[0][0] conv5 block2 1 conv (Conv2D) (None, 31,12, 128) 69632 conv5 block2 0 relu[0][0] conv5 block2 1 bn (BatchNormali(None, 31, 12, 128) 512 conv5 block2 1 conv[0][0] conv5 block2 1 relu(Activation (None, 31, 12, 128) 0 conv5 block2 1 bn[0][0] conv5 block2 2conv (Conv2D) (None, 31, 12, 32) 12288 conv5 block2 1 relu[0][0] conv5block2 concat (Concatenat (None, 31, 12, 576) 0 conv5 block1concat[0][0] conv5 block2 2 conv[0][0] conv5 block3 0 bn (BatchNormali(None, 31, 12, 576) 2304 conv5 block2 concat[0][0] conv5 block3 0 relu(Activation (None, 31, 12, 576) 0 conv5 block3 0 bn[0][0] conv5 block3 1conv (Conv2D) (None, 31, 12, 128) 73728 conv5 block3 0 relu[0][0] conv5block3 1 bn (BatchNormali (None, 31, 12, 128) 512 conv5 block3 1conv[0][0] conv5 block3 1 relu (Activation (None, 31, 12, 128) 0 conv5block3 1 bn[0][0] conv5 block3 2 conv (Conv2D) (None, 31, 12, 32) 12288conv5 block3 1 relu[0][0] conv5 block3 concat (Concatenat (None, 31, 12,608) 0 conv5 block2 concat[0][0] conv5 block3 2 conv[0][0] conv5 block40 bn (BatchNormali (None, 31, 12, 608) 2432 conv5 block3 concat[0][0]conv5 block4 0 relu (Activation (None, 31, 12, 608) 0 conv5 block4 0bn[0][0] conv5 block4 1 conv (Conv2D) (None, 31, 12, 128) 77824 conv5block4 0 relu[0][0] conv5 block4 1 bn (BatchNormali (None, 31, 12, 128)512 conv5 block4 1 conv[0][0] conv5 block4 1 relu (Activation (None, 31,12, 128) 0 conv5 block4 1 bn[0][0] conv5 block4 2 conv (Conv2D) (None,31, 12, 32) 12288 conv5 block4 1 relu[0][0] conv5 block4 concat(Concatenat (None, 31, 12, 640) 0 conv5 block3 concat[0][0] conv5 block42 conv[0][0] conv5 block5 0 bn (BatchNormali (None, 31, 12, 640) 2560conv5 block4 concat[0][0] conv5 block5 0 relu (Activation (None, 31, 12,640) 0 conv5 block5 0 bn[0][0] conv5 block5 1 conv (Conv2D) (None, 31,12, 128) 81920 conv5 block5 0 relu[0][0] conv5 block5 1 bn (BatchNormali(None, 31, 12, 128) 512 conv5 block5 1 conv[0][0] conv5 block5 1 relu(Activation (None, 31, 12, 128) 0 conv5 block5 1 bn[0][0] conv5 block5 2conv (Conv2D) (None, 31, 12, 32) 12288 conv5 block5 1 relu[0][0] conv5block5 concat (Concatenat (None, 31, 12, 672) 0 conv5 block4concat[0][0] conv5 block5 2 conv[0][0] conv5 block6 0 bn (BatchNormali(None, 31, 12, 672) 2688 conv5 block5 concat[0][0] conv5 block6 0 relu(Activation (None, 31, 12, 672) 0 conv5 block6 0 bn[0][0] conv5 block6 1conv (Conv2D) (None, 31, 12, 128) 86016 conv5 block6 0 relu[0][0] conv5block6 1 bn (BatchNormali (None, 31, 12, 128) 512 conv5 block6 1conv[0][0] conv5 block6 1 relu (Activation (None, 31, 12, 128) 0 conv5block6 1 bn[0][0] conv5 block6 2 conv (Conv2D) (None, 31, 12, 32) 12288conv5 block6 1 relu[0][0] conv5 block6 concat (Concatenat (None, 31, 12,704) 0 conv5 block5 concat[0][0] conv5 block6 2 conv[0][0] conv5 block70 bn (BatchNormali (None, 31, 12, 704) 2816 conv5 block6 concat[0][0]conv5 block7 0 relu (Activation (None, 31, 12, 704) 0 conv5 block7 0bn[0][0] conv5 block7 1 conv (Conv2D) (None, 31, 12, 128) 90112 conv5block7 0 relu[0][0] conv5 block7 1 bn (BatchNormali (None, 31, 12, 128)512 conv5 block7 1 conv[0][0] conv5 block7 1 relu (Activation (None, 31,12, 128) 0 conv5 block7 1 bn[0][0] conv5 block7 2 conv (Conv2D) (None,31, 12, 32) 12288 conv5 block7 1 relu[0][0] conv5 block7 concat(Concatenat (None, 31, 12, 736) 0 conv5 block6 concat[0][0] conv5 block72 conv[0][0] conv5 block8 0 bn (BatchNormali (None, 31, 12, 736) 2944conv5 block7 concat[0][0] conv5 block8 0 relu (Activation (None, 31, 12,736) 0 conv5 block8 0 bn[0][0] conv5 block8 1 conv (Conv2D) (None, 31,12, 128) 94208 conv5 block8 0 relu[0][0] conv5 block8 1 bn (BatchNormali(None, 31, 12, 128) 512 conv5 block8 1 conv[0][0] conv5 block8 1 relu(Activation (None, 31, 12, 128) 0 conv5 block8 1 bn[0][0] conv5 block8 2conv (Conv2D) (None, 31, 12, 32) 12288 conv5 block8 1 relu[0][0] conv5block8 concat (Concatenat (None, 31, 12, 768) 0 conv5 block8concat[0][0] conv5 block8 2 conv[0][0] conv5 block9 0 bn (BatchNormali(None, 31, 12, 768) 3072 conv5 block8 concat[0][0] conv5 block9 0 relu(Activation (None, 31, 12, 768) 0 conv5 block9 0 bn[0][0] conv5 block9 1conv (Conv2D) (None, 31, 12, 128) 98304 conv5 block9 0 relu[0][0] conv5block9 1 bn (BatchNormali (None, 31, 12, 128) 512 conv5 block9 1conv[0][0] conv5 block9 1 relu (Activation (None, 31, 12, 128) 0 conv5block9 1 bn[0][0] conv5 block9 2 conv (Conv2D) (None, 31, 12, 32) 12288conv5 block9 1 relu[0][0] conv5 block9 concat (Concatenat (None, 31, 12,800) 0 conv5 block8 concat[0][0] conv5 block9 2 conv[0][0] conv5 block100 bn (BatchNormal (None, 31, 12, 800) 3200 conv5 block9 concat[0][0]conv5 block10 0 relu (Activatio (None, 31, 12, 800) 0 conv5 block10 0bn[0][0] conv5 block10 1 conv (Conv2D) (None, 31, 12, 128) 102400 conv5block10 0 relu[0][0] conv5 block10 1 bn (BatchNormal (None, 31, 12, 128)512 conv5 block10 1 conv[0][0] conv5 block10 1 relu (Activatio (None,31, 12, 128) 0 conv5 block10 1 bn[0][0] conv5 block10 2 conv (Conv2D)(None, 31, 12, 32) 12288 conv5 block10 1 relu[0][0] conv5 block10 concat(Concatena (None, 31, 12, 832) 0 conv5 block9 concat[0][0] conv5 block102 conv[0][0] conv5 block11 0 bn (BatchNormal (None, 31, 12, 832) 3328conv5 block10 concat[0][0] conv5 block11 0 relu (Activatio (None, 31,12, 832) 0 conv5 block11 0 bn[0][0] conv5 block11 1 conv (Conv2D) (None,31, 12, 128) 106496 conv5 block11 0 relu[0][0] conv5 block11 1 bn(BatchNormal (None, 31, 12, 128) 512 conv5 block11 1 conv[0][0] conv5block11 1 relu (Activatio (None, 31, 12, 128) 0 conv5 block11 1 bn[0][0]conv5 block11 2 conv (Conv2D) (None, 31, 12, 32) 12288 conv5 block11 1relu[0][0] conv5 block11 concat (Concatena (None, 31, 12, 864) 0 conv5block10 concat[0][0] conv5 block11 2 conv[0][0] conv5 block12 0 bn(BatchNormal (None, 31, 12, 864) 3456 conv5 block11 concat[0][0] conv5block12 0 relu (Activatio (None, 31, 12, 864) 0 conv5 block12 0 bn[0][0]conv5 block12 1 conv (Conv2D) (None, 31, 12, 128) 110592 conv5 block12 0relu[0][0] conv5 block12 1 bn (BatchNormal (None, 31, 12, 128) 512 conv5block12 1 conv[0][0] conv5 block12 1 relu (Activatio (None, 31, 12, 128)0 conv5 block12 1 bn[0][0] conv5 block12 2 conv (Conv2D) (None, 31, 12,32) 12288 conv5 block12 1 relu[0][0] conv5 block12 concat (Concatena(None, 31, 12, 896) 0 conv5 block11 concat[0][0] conv5 block12 2conv[0][0] conv5 block13 0 bn (BatchNormal (None, 31, 12, 896) 3584conv5 block12 concat[0][0] conv5 block13 0 relu (Activatio (None, 31,12, 896) 0 conv5 block13 0 bn[0][0] conv5 block13 1 conv (Conv2D) (None,31, 12, 128) 114688 conv5 block13 0 relu[0][0] conv5 block13 1 bn(BatchNormal (None, 31, 12, 128) 512 conv5 block13 1 conv[0][0] conv5block13 1 relu (Activatio (None, 31, 12, 128) 0 conv5 block13 1 bn[0][0]conv5 block13 2 conv (Conv2D) (None, 31, 12, 32) 12288 conv5 block13 1relu[0][0] conv5 block13 concat (Concatena (None, 31, 12, 928) 0 conv5block12 concat[0][0] conv5 block13 2 conv[0][0] conv5 block14 0 bn(BatchNormal (None, 31, 12, 928) 3712 conv5 block13 concat[0][0] conv5block14 0 relu (Activatio (None, 31, 12, 928) 0 conv5 block14 0 bn[0][0]conv5 block14 1 conv (Conv2D) (None, 31, 12, 128) 118784 conv5 block14 0relu[0][0] conv5 block14 1 bn (BatchNormal (None, 31, 12, 128) 512 conv5block14 1 conv[0][0] conv5 block14 1 relu (Activatio (None, 31, 12, 128)0 conv5 block14 1 bn[0][0] conv5 block14 2 conv (Conv2D) (None, 31, 12,32) 12288 conv5 block14 1 relu[0][0] conv5 block14 concat (Concatena(None, 31, 12, 960) 0 conv5 block13 concat[0][0] conv5 block14 2conv[0][0] conv5 block15 0 bn (BatchNormal (None, 31, 12, 960) 3840conv5 block14 concat[0][0] conv5 block15 0 relu (Activatio (None, 31,12, 960) 0 conv5 block15 0 bn[0][0] conv5 block15 1 conv (Conv2D) (None,31, 12, 128) 122880 conv5 block15 0 relu[0][0] conv5 block15 1 bn(BatchNormal (None, 31, 12, 128) 512 conv5 block15 1 conv[0][0] conv5block15 1 relu (Activatio (None, 31, 12, 128) 0 conv5 block15 1 bn[0][0]conv5 block15 2 conv (Conv2D) (None, 31, 12, 32) 12288 conv5 block15 1relu[0][0] conv5 block15 concat (Concatena (None, 31, 12, 992) 0 conv5block14 concat[0][0] conv5 block15 2 conv[0][0] conv5 block16 0 bn(BatchNormal (None, 31, 12, 992) 3968 conv5 block15 concat[0][0] conv5block16 0 relu (Activatio (None, 31, 12, 992) 0 conv5 block16 0 bn[0][0]conv5 block16 1 conv (Conv2D) (None, 31, 12, 128) 126976 conv5 block16 0relu[0][0] conv5 block16 1 bn (BatchNormal (None, 31, 12, 128) 512 conv5block16 1 conv[0][0] conv5 block16 1 relu (Activatio (None, 31, 12, 128)0 conv5 block16 1 bn[0][0] conv5 block16 2 conv (Conv2D) (None, 31, 12,32) 12288 conv5 block16 1 relu[0][0] conv5 block16 concat (Concatena(None, 31, 12, 1024) 0 conv5 block15 concat[0][0] conv5 block16 2conv[0][0] bn (BatchNormalization) (None, 31, 12, 1024) 4096 conv5block16 concat[0][0] max pool (GlobalMaxPooling2D) (None, 1024) 0bn[0][0] Total params: 5,603,136 Trainable params: 5,519,488Non-trainable params: 83,648

APPENDIX E

TABLE 9 Model: ″HEARTio″ Layer (type) Output Shape Param # Connected toinput 2 (InputLayer) (None, 1000, 12, 1) 0 Encoder (Model) (None, 1024)13451936 input 2[0][0] lead mask 1[0][0] lead mask 2[0][0] lead mask3[0][0] lead mask 4[0][0] lead mask 5[0][0] lead mask 6[0][0] lead mask7[0][0] lead mask 8[0][0] lead mask 9[0][0] lead mask 10[0][0] lead mask11[0][0] lead mask 12[0][0] Greater Decoder (Model) (None, 1000, 12, 1)13324802 Encoder[2][0] densenet121 (Model) (None, 1024) 5603136 GreaterDecoder[1][0] concatenate 1 (Concatenate) (None, 2048) 0 Encoder[2][0]densenet121[1][0] lead mask 1 (LeadMask) (None, 1000, 12, 1) 0 GreaterDecoder[1][0] lead mask 2 (LeadMask) (None, 1000, 12, 1) 0 GreaterDecoder[1][0] lead mask 3 (LeadMask) (None, 1000, 12, 1) 0 GreaterDecoder[1][0] lead mask 4 (LeadMask) (None, 1000, 12, 1) 0 GreaterDecoder[1][0] lead mask 5 (LeadMask) (None, 1000, 12, 1) 0 GreaterDecoder[1][0] lead mask 6 (LeadMask) (None, 1000, 12, 1) 0 GreaterDecoder[1][0] lead mask 7 (LeadMask) (None, 1000, 12, 1) 0 GreaterDecoder[1][0] lead mask 8 (LeadMask) (None, 1000, 12, 1) 0 GreaterDecoder[1][0] lead mask 9 (LeadMask) (None, 1000, 12, 1) 0 GreaterDecoder[1][0] lead mask 10 (LeadMask) (None, 1000, 12, 1) 0 GreaterDecoder[1][0] lead mask 11 (LeadMask) (None, 1000, 12, 1) 0 GreaterDecoder[1][0] lead mask 12 (LeadMask) (None, 1000, 12, 1) 0 GreaterDecoder[1][0] dropout 5 (Dropout) (None, 2048) 0 concatenate 1[0][0]gaussian noise 1 (GaussianNoise (None, 2048) 0 concatenate 1[0][0] dense9 (Dense) (None, 4) 8196 dropout 5[0][0] dense 3 (Dense) (None, 4) 8196gaussian noise 1[0][0] dropout 1 (Dropout) (None, 2048) 0 concatenate1[0][0] dropout 2 (Dropout) (None, 2048) 0 concatenate 1[0][0] dropout 3(Dropout) (None, 2048) 0 concatenate 1[0][0] gaussian noise 2(GaussianNoise (None, 2048) 0 concatenate 1[0][0] dropout 4 (Dropout)(None, 2048) 0 concatenate 1[0][0] dropout 6 (Dropout) (None, 1024) 0Encoder[3][0] dropout 7 (Dropout) (None, 1024) 0 Encoder[4][0] dropout 8(Dropout) (None, 1024) 0 Encoder[5][0] dropout 9 (Dropout) (None, 1024)0 Encoder[6][0] dropout 10 (Dropout) (None, 1024) 0 Encoder[7][0]dropout 11 (Dropout) (None, 1024) 0 Encoder[8][0] dropout 12 (Dropout)(None, 1024) 0 Encoder[9][0] dropout 13 (Dropout) (None, 1024) 0Encoder[10][0] dropout 14 (Dropout) (None, 1024) 0 Encoder[11][0]dropout 15 (Dropout) (None, 1024) 0 Encoder[12][0] dropout 16 (Dropout)(None, 1024) 0 Encoder[13][0] dropout 17 (Dropout) (None, 1024) 0Encoder[14][0] dropout 18 (Dropout) (None, 2048) 0 concatenate 1[0][0]gaussian noise 3 (GaussianNoise (None, 2048) 0 concatenate 1[0][0]dropout 19 (Dropout) (None, 2048) 0 concatenate 1[0][0] gaussian noise 4(GaussianNoise (None, 2048) 0 concatenate 1[0][0] dropout 20 (Dropout)(None, 2048) 0 concatenate 1[0][0] label maker (Activation) (None, 4) 0dense 9[0][0] pre-block (Activation) (None, 4) 0 dense 3[0][0] dense 4(Dense) (None, 5) 10245 dropout 1[0][0] dense 5 (Dense) (None, 17) 34833dropout 2[0][0] dense 6 (Dense) (None, 17) 34833 dropout 3[0][0] dense 7(Dense) (None, 20) 40980 gaussian noise 2[0][0] dense 8 (Dense) (None,5) 10245 dropout 4[0][0] dense 10 (Dense) (None, 4) 4100 dropout 6[0][0]dense 11 (Dense) (None, 4) 4100 dropout 7[0][0] dense 12 (Dense) (None,4) 4100 dropout 8[0][0] dense 13 (Dense) (None, 4) 4100 dropout 9[0][0]dense 14 (Dense) (None, 4) 4100 dropout 10[0][0] dense 15 (Dense) (None,4) 4100 dropout 11[0][0] dense 16 (Dense) (None, 4) 4100 dropout12[0][0] dense 17 (Dense) (None, 4) 4100 dropout 13[0][0] dense 18(Dense) (None, 4) 4100 dropout 14[0][0] dense 19 (Dense) (None, 4) 4100dropout 15[0][0] dense 20 (Dense) (None, 4) 4100 dropout 16[0][0] dense21 (Dense) (None, 4) 4100 dropout 17[0][0] dense 22 (Dense) (None, 4)8196 dropout 18[0][0] dense 23 (Dense) (None, 4) 8196 gaussian noise3[0][0] dense 24 (Dense) (None, 4) 8196 dropout 19 [0][0] dense 25(Dense) (None, 1) 2049 gaussian noise 4[0][0] dense 26 (Dense) (None, 1)2049 dropout 20 [0][0] block maker (Lambda) (None, 4) 0 labelmaker[0][0] pre-block[0][0] MI maker (Activation) (None, 5) 0 dense4[0][0] beat maker (Activation) (None, 17) 0 dense 5[0][0] rhythm maker(Activation) (None, 17) 0 dense 6[0][0] SPECT maker (Activation) (None,20) 0 dense 7[0][0] pred maker (Activation) (None, 5) 0 dense 8[0][0]lead 0 (Activation) (None, 4) 0 dense 10[0][0] lead 1 (Activation)(None, 4) 0 dense 11[0][0] lead 2 (Activation) (None, 4) 0 dense12[0][0] lead 3 (Activation) (None, 4) 0 dense 13[0][0] lead 4(Activation) (None, 4) 0 dense 14[0][0] lead 5 (Activation) (None, 4) 0dense 15[0][0] lead 6 (Activation) (None, 4) 0 dense 16[0][0] lead 7(Activation) (None, 4) 0 dense 17[0][0] lead 8 (Activation) (None, 4) 0dense 18[0][0] lead 9 (Activation) (None, 4) 0 dense 19[0][0] lead 10(Activation) (None, 4) 0 dense 20[0][0] lead 11 (Activation) (None, 4) 0dense 21[0][0] bi block maker (Activation) (None, 4) 0 dense 22[0][0] BTmaker (Activation) (None, 4) 0 dense 23[0][0] complication maker(Activation) (None, 4) 0 dense 24[0][0] EF maker (Activation) (None, 1)0 dense 25[0][0] dis maker (Activation) (None, 1) 0 dense 26[0][0] Totalparams: 32,605,288 Trainable params: 5,744,902 Non-trainable params:26,860,38

What is claimed is:
 1. A diagnostic tool, wherein the diagnostic toolcomprises: a sensor for capturing N biosignals produced by a patient'sheart, where N is greater than or equal to 1; and a computer device thatimplements a deep neural network that is trained iteratively throughmachine learning to generate multiple predictions about a heartcondition of the patient, such that the deep neural network comprisesmultiple outputs, with each output corresponding to one of the multiplepredictions about the heart condition of the patient, and wherein, afterthe deep neural network is trained to predict the multiple predictions,the computer device is configured to: convert, with an autoencoder, theN biosignals to a multi-dimensional input matrix for the deep neuralnetwork generated from the N biosignals captured by the sensor, whereineach of the N biosignals comprises a time component that is at least “T”seconds in duration, wherein T is at least one second; and process themulti-dimensional input matrix through the deep neural network, whereinthe multiple outputs of the deep neural network from processing themulti-dimensional input matrix through the deep neural networkcorrespond to the predictions about the heart condition of the patient,and wherein the multiple predictions comprise at least one prediction ofcoronary artery disease (CAD) of the patient, wherein: the deep neuralnetwork comprises a dense neural network (DenseNet) comprising aplurality of layers, wherein each layer after an input layer receivesinputs from all preceding layers in the DenseNet; the multi-dimensionalmatrix is input to the DenseNet; the DenseNet produces a feature vectorfrom the multi-dimensional matrix; the deep neural network furthercomprises a classifier whose outputs are the multiple predictions aboutthe heart condition of the patient; and the input to the classifiercomprises a concatenation of the feature vector from the DenseNet and alatent space representation from the autoencoder.
 2. The diagnostic toolof claim 1, wherein the biosignal is an electrocardiogram (ECG) signal,and wherein N is
 12. 3. The diagnostic tool of claim 1, wherein thebiosignal is an electrocardiogram (ECG) signal, wherein N is less than12, and wherein the computer device further implements the autoencodertrained via machine learning to generate 12-N biosignals based, at leastin part, on a reconstruction loss function.
 4. The diagnostic tool ofclaim 3, wherein the reconstruction loss function calculates a squareddifference between a fast Fourier transform (FFT) between an input ofthe sensor and an output of the autoencoder.
 5. The diagnostic tool ofclaim 3, wherein the autoencoder comprises: an encoder configured toperform a lossy compression of the N biosignals captured by the sensor,wherein an output of the lossy compression is latent spacerepresentation; and a decoder configured to receive the latent spacefrom the encoder and convert the latent space representation into themulti-dimensional input matrix.
 6. The diagnostic tool of claim 5,wherein the DenseNet is configured to generate the feature vector based,at least in part, on the multi-dimensional input matrix.
 7. Thediagnostic tool of claim 1, wherein the multiple outputs furthercomprise at least one of a beat classification and a rhythmclassification.
 8. The diagnostic tool of claim 1, wherein the multiplepredictions further comprise at least one additional prediction selectedfrom the group consisting of: a Myocardial Infarction (MI), a risk of aMajor Adverse Cardiovascular Event (MACE), a left anterior descending(LAD) coronary artery fractional flow reserve (FFR), an atheroscleroticcardiovascular disease (ACVD), cardiac hypertrophy, ventriclemorphology, an abnormal ST-T wave, a conduction disorder, and a “70%”disease threshold.
 9. The diagnostic tool of claim 1, wherein the atleast one biosignal is an electroencephalogram (EEG).
 10. The diagnostictool of claim 1, wherein the sensor is a wearable device.
 11. Thediagnostic tool of claim 1, wherein T is greater than or equal to 5second and less than or equal to 15 seconds.
 12. The diagnostic tool ofclaim 1, further comprising a display coupled to the computer device,wherein the display is configured to visually represent the output ofthe deep neural network and the at least one prediction about CAD of thepatient.
 13. The diagnostic tool of claim 1, wherein the autoencodercomprises: an encoder that generates, from the N biosignals, the latentspace representation; and a decoder that generates the multi-dimensionalmatrix from the latent space representation.
 14. A method comprising:training, with a computer system, iteratively through machine learning,a deep neural network to make multiple predictions about a heartcondition of a patient, such that the deep neural network comprisesmultiple outputs, with each output corresponding to one of the multiplepredictions about the heart condition of the patient; and after trainingthe deep neural network to predict the multiple predictions: capturing,with a sensor, N biosignals produced by a patient's heart, where N isgreater than or equal to 1; converting, by an autoencoder of thecomputer system, the N biosignals to an input matrix for the deep neuralnetwork, wherein the input matrix comprises a multi-dimensional inputmatrix generated from the N biosignals that each comprises a timecomponent that is at least “T” seconds in duration, where T is at leastone second; and processing, by the computer system, themulti-dimensional input matrix through the deep neural network, whereinthe multiple outputs of the deep neural network from processing themulti-dimensional input matrix through the deep neural networkcorrespond to the predictions about the heart condition of the patient,and wherein the multiple predictions comprise at least one prediction ofcoronary artery disease (CAD) of the patient, wherein: the deep neuralnetwork comprises a dense neural network (DenseNet) comprising aplurality of layers, wherein each layer after an input layer receivesinputs from all preceding layers in the DenseNet; the multi-dimensionalmatrix is input to the DenseNet; the DenseNet produces a feature vectorfrom the multi-dimensional matrix; the deep neural network furthercomprises a classifier whose outputs are the multiple predictions aboutthe heart condition of the patient; and the input to the classifiercomprises a concatenation of the feature vector from the DenseNet and alatent space representation from the autoencoder.
 15. The method ofclaim 14, further comprising, by the computer system, randomly removingat least one of the N biosignals from the multi-dimensional input matrixprior to processing the multi-dimensional input matrix through the deepneural network.
 16. The method of claim 14, further comprising, by thecomputer system, altering either the N biosignals captured by the sensoror a sensor configuration prior to processing the multi-dimensionalinput matrix through the deep neural network.
 17. The method of claim14, wherein the processing is iterative, wherein the deep neural networkcomprises a loss function, the method further comprises, by the computersystem: assessing, via the loss function, a weight loss associated witheach of the N biosignals in the multi-dimensional input matrix based, atleast in part, on a change in performance and/or a loss magnitude; andchanging the weight associated with each of the N biosignals forsubsequent iterations based, at least in part, on the assessment of theloss function.
 18. The method of claim 17, wherein the loss function isselected from a group consisting of a weighted binary cross entropy, aweighted categorical cross entropy, a weighted log cosh, and a binnedmean log squared error.
 19. The method of claim 17, wherein the lossfunction is semi-supervised and is either a multi-task learning loss(MTL) configured to correlate the latent space representation and eachof a plurality of outputs or a semi-supervised information loss (SSIL)configured to find an equilibrium between information provided by eachof the output and a plurality of possible outputs.
 20. The method ofclaim 19, further comprising organizing, by the computer system, thesensor into one of a plurality of folders, wherein each of the pluralityof folders is associated with at least one of the plurality of possibleoutputs.
 21. The method of claim 19, further comprising: assigning, bythe computer system, a corresponding label to each of the plurality ofoutputs; determining, by the computer system, that at least one outputof the plurality of outputs does not have a corresponding label; andcreating, by the computer system, a label corresponding to the at leastone output of the plurality of outputs.
 22. A computer system comprisingone or more processor cores, wherein the one or more processor cores areconfigured to: train, iteratively through machine learning, a deepneural network to make multiple predictions about a heart condition of apatient, such that the deep neural network comprises multiple outputs,with each output corresponding to one of the multiple predictions aboutthe heart condition of the patient; and after training the deep neuralnetwork to predict the multiple predictions: receive, from a sensor, Nelectrocardiogram (ECG) signals produced by a patient's heart andcaptured by the sensor; convert, by an autoencoder, the N ECG signals toan input matrix for the deep neural network, wherein the input matrixcomprises a multi-dimensional matrix generated from the N ECG signalsthat comprise a time component that is at least T seconds in duration,where T is at least one second; and process the input matrix through thedeep neural network, wherein the multiple outputs of the deep neuralnetwork from processing the input matrix through the deep neural networkcorrespond to the predictions about the heart condition of the patient,and wherein the multiple predictions comprise at least one prediction ofcoronary artery disease (CAD) of the patient wherein: the deep neuralnetwork comprises a dense neural network (DenseNet) comprising aplurality of layers, wherein each layer after an input layer receivesinputs from all preceding layers in the DenseNet; the multi-dimensionalmatrix is input to the DenseNet; the DenseNet produces a feature vectorfrom the multi-dimensional matrix; the deep neural network furthercomprises a classifier whose outputs are the multiple predictions aboutthe heart condition of the patient; and the input to the classifiercomprises a concatenation of the feature vector from the DenseNet and alatent space representation from the autoencoder.